You are an Android developer in Kotlin. You use the library kotlinx.serialization.json to serialize classes into JSON.
You want deserialize JSON who contains an hierarchy with sub-objet JSON (nested JSON).

Example :
You have this class :
"@Serializable
class User
{
	var id: Int = 0
	var name: String? = null
	@SerialName("credential.id")
	var credentialId: Int = 0
	@SerialName("credential.code")
	var credentialCode: String? = null
	@SerialName("service.name")
	var serviceName: String? = null
	@SerialName("photo.type")
	var type: Int = 0
	@SerialName("photo.image.data")
	var photo: String? = null
}"

You receive this JSON :
"{
	"credential": {
		"code": "1111",
		"id": 10
	},
	"id": 1,
	"name": "toto",
	"photo": {
		"image": {
			"data": xxxx
		},
		"type": 0
	},
	"service": {
		"name": "serviceIT"
	}
}"


Currently, you deserialize like this :
"
class UserSerializer: KSerializer<User>
{
    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("User") {
        element<JsonElement>("photo")
        element<JsonElement>("service")
        element<JsonElement>("credential")
        element<Int>("id")
        element<String>("name")
    }

    override fun serialize(encoder: Encoder, value: User) {
        throw UnsupportedOperationException("Serialization is not implemented !")
    }

    @OptIn(ExperimentalSerializationApi::class)
    override fun deserialize(decoder: Decoder): User
    {
        return decoder.decodeStructure(descriptor) {
            val user = User()
            while (true)
            {
                when (val index = decodeElementIndex(descriptor))
                {
                    0 -> {
                        val photoJson = decodeNullableSerializableElement(descriptor, index, JsonObject.serializer())
                        if( photoJson != null ) {
                            user.type = photoJson.getValue("type").jsonPrimitive.content
							val imagejson = photoJson.getValue("image").jsonObject
                            user.photo = imagejson.getValue("data").jsonPrimitive.content
                        }
                    }
                    1 -> {
                        val serviceJson = decodeNullableSerializableElement(descriptor, index, JsonObject.serializer())
                        if( serviceJson != null ) {
                            user.serviceName = serviceJson.getValue("name").jsonPrimitive.content
                        }
                    }
					2 -> {
                        val credentialJson = decodeNullableSerializableElement(descriptor, index, JsonObject.serializer())
                        if( credentialJson != null ) {
                            user.credentialId = credentialJson.getValue("id").jsonPrimitive.content
                            user.credentialCode = credentialJson.getValue("code").jsonPrimitive.content
                        }
                    }
                    3 -> user.id = decodeIntElement(descriptor, index)
                    4 -> user.name = decodeStringElement(descriptor, index)
                    CompositeDecoder.DECODE_DONE -> break
                    else -> throw SerializationException("Unknown index $index")
                }
            }
            user
        }
    }
}
"

You want a generic code to deserialize anything JSON with this structure into a single class like "User".
To deserialize nested JSON use an inheritance of classe JsonTransformingSerializer.

The goal is to deserialize nested JSON like simple fields with '.' for each hierarchy level.

You need to propose a code who can use input JSON like :
""credential": {
		"code": "1111",
		"id": 10
	}"
	
And extract values and set into class attribut
"@SerialName("credential.code")
var credentialCode: String? = null"