Kotlin Serialization ガイド　第1章 基本的なシリアライゼーション

#はじめに
　[Kotlin Serialization ガイドの目次](https://qiita.com/guijiu/items/097e858e4930b6d7e6c0)に基づいて「[Kotlin Serialization guide](https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serialization-guide.md#kotlin-serialization-guide)」を訳しています。
　なお、翻訳には[DeepL](https://www.deepl.com/translator)の力を９９％借りています。
　もし、一緒に「[Kotlin Serialization ガイド](https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serialization-guide.md#kotlin-serialization-guide)」の翻訳をして下さる方がいらっしゃいましたら、コメント欄などから連絡をください。

##第1章 基本的なシリアライゼーション＜[原文](https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/basic-serialization.md#basic-serialization)＞

<!--- TEST_NAME BasicSerializationTest -->

Latest commit 728e220 on 24 Nov 2020版

　[Kotlin Serialization Guide](serialization-guide.md)の第1章です。この章では、Kotlin Serializationの基本的な使い方を示し、その核となる概念を解説しています。

**目次** 

<!--- TOC -->

* [基本](#基本)
  * [JSONエンコーディング](#json-エンコーディング)
  * [JSONデコーディング](#json-デコーディング)
* [シリアライゼーション-クラス](#シリアライゼーション-クラス)
  * [バッキングフィールドはシリアライズされています](#バッキングフィールドはシリアル化されています)
  * [コンストラクタのプロパティ要件](#コンストラクタのプロパティ要件)
  * [データの検証](#データの検証)
  * [オプションのプロパティ](#オプションのプロパティ)
  * [オプションのプロパティイニシャライザの呼び出し](#オプションのプロパティイニシャライザの呼び出し)
  * [必要なプロパティ](#必要なプロパティ)
  * [トランジェントプロパティ](#トランジェントプロパティ)
  * [デフォルトはエンコードされない](#デフォルト値はエンコードされない)
  * [ヌル可能なプロパティ](#ヌル可能なプロパティ)
  * [型安全性の確保](#型安全性の確保)
  * [参照されたオブジェクト](#参照されたオブジェクト)
  * [繰り返し参照を圧縮しないでください](#繰り返し参照を圧縮しないでください)
  * [ジェネリッククラス](#ジェネリッククラス)
  * [シリアルフィールド名](#シリアルフィールド名)

<!--- END -->

#基本

　オブジェクトツリーを文字列またはバイト列に変換するには、相互に絡み合う 2 つのプロセスを経る必要があります。最初のステップでは、オブジェクトはシリアライズ(直列化)され、その構成する直列化したプリミティブ値の変換されます。このプロセス(過程)はすべてのデータ形式に共通しており、その結果はシリアル化されるオブジェクトに依存します。シリアライザは、このプロセスを制御します。2 番目のステップはエンコーディングと呼ばれ、対応する一連のプリミティブな値を出力フォーマットで定めた表現に変換します。エンコーダがこのプロセスを制御します。この区別が重要でない場合は、エンコーディングとシリアライゼーションの両方の用語を互換性を持って使用します。

```
+---------+  Serialization  +------------+  Encoding  +---------------+
| Objects | --------------> | Primitives | ---------> | Output format |
+---------+                 +------------+            +---------------+
```

　逆の処理は、入力フォーマットの解析とプリミティブ値ので案コード(復元)から始まり、結果として得られたストリームをオブジェクトに_デシリアライズすることになります。この処理の詳細については後ほど説明します。
　先ずは、[JSON](https://json.org) のエンコーディングから始めます。

<!--- INCLUDE .*-basic-.*import kotlinx.serialization.*import kotlinx.serialization.json.*-->

### JSON エンコーディング
　データを特定の形式に変換するプロセス全体を“エンコーディング”と呼びます。JSONの場合は、[Json.encodeToString][kotlinx.serialization.encodeToString]拡張関数を使ってデータをエンコードします。これは、パラメータとして渡されたオブジェクトをシリアル化し、JSON 文字列にエンコードします。
　プロジェクトを記述するクラスから始めて、そのJSON表現を取得してみましょう。

```kotlin 
class Project(val name: String, val language: String)

fun main() {
    val data = Project("kotlinx.serialization", "Kotlin")
    println(Json.encodeToString(data))
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-basic-01.kt).から取得できます。

　このコードを実行すると、例外が発生します。

```text 
スレッド "main" での例外 kotlinx.serialization.SerializationException. クラス 'Project' 用のシリアライザが見つかりません。
クラスを @Serializable としてマークするか、シリアライザを明示的に提供します。
```

<!--- TEST LINES_START -->

　シリアライズ可能なクラスは明示的にマークする必要があります。Kotlin Serialization はリフレクションを使用しないので、シリアル化できるはずのないクラスを誤ってデシリアライズしてしまうことはありません。これを修正するために、[`@Serializable`][Serializable]アノテーションを追加しました。

```kotlin
@Serializable 
class Project(val name: String, val language: String)

fun main() {
    val data = Project("kotlinx.serialization", "Kotlin")
    println(Json.encodeToString(data))
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-basic-02.kt)から取得できます。

　Serializable` アノテーションは、 Kotlin Serialization プラグインにこのクラス用のシリアライザを自動的に生成して、フックアップするように指示します。これで、例の出力は対応するJSONになりました。


```text
{"name":"kotlinx.serialization","language":"Kotlin"}
```

<!--- TEST -->    

> [Serializers](https://qiita.com/guijiu/items/be7fa14c49cb7e3006dd#%E7%AC%AC3%E7%AB%A0-%E3%82%B7%E3%83%AA%E3%82%A2%E3%83%A9%E3%82%A4%E3%82%B6-%E5%8E%9F%E6%96%87)についての章があります。今のところ、Kotlin Serializationプラグインによって自動的に生成されることを知っていれば十分です。                                


### JSON デコーディング

　この逆の処理をデコーディングと呼びます。JSON 文字列をオブジェクトにデコードするには、[Json.decodeFromString](https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/decode-from-string.html)拡張関数を使用します。結果として取得したい型を指定するために、この関数に型パラメータを指定します。

　この後示すように、シリアライズは異なる種類のクラスで動作します。ここでは `Project` クラスを `データクラス` としてマークしているが、これは必須ではなく、その内容を印刷してデコード方法を確認したいからである。

```kotlin
@Serializable 
data class Project(val name: String, val language: String)

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization","language":"Kotlin"}
    """)
    println(data)
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-basic-03.kt)から取得できます。

　このコードを実行すると、オブジェクトが戻ってきます。

```text
Project(name=kotlinx.serialization, language=Kotlin)
```

<!--- TEST -->          

## シリアライゼーション クラス

　このセクションでは、異なる `@Serializable` クラスがどのように扱われるかについて詳しく説明します。                          

<!--- INCLUDE .*-classes-.*
import kotlinx.serialization.*
import kotlinx.serialization.json.*
-->

### バッキングフィールドはシリアル化されています。

　バッキングフィールドを持つクラスのプロパティのみがシリアライズされるため、以下の例のようにバッキングフィールドを持たないゲッター/セッターとデリゲートされたプロパティはシリアライズされません。

```kotlin        
@Serializable 
class Project(
    // name is a property with backing field -- serialized
    var name: String
) {
    var stars: Int = 0 // property with a backing field -- serialized
 
    val path: String // getter only, no backing field -- not serialized
        get() = "kotlin/$name"                                         

    var id by ::name // delegated property -- not serialized
}

fun main() {
    val data = Project("kotlinx.serialization").apply { stars = 9000 }
    println(Json.encodeToString(data))
}
``` 

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-01.kt)から取得できます。

　JSON出力には `name` と `stars` プロパティだけが存在することがわかります。

```text 
{"name":"kotlinx.serialization","stars":9000}
```

<!--- TEST -->


### コンストラクタのプロパティ要件

　プロジェクトクラスを定義してパス文字列を受け取り、それを対応するプロパティに分解するようにしたい場合、以下のコードのようなものを書きたくなるかもしれません。

```kotlin
@Serializable 
class Project(path: String) {
    val owner: String = path.substringBefore('/')    
    val name: String = path.substringAfter('/')    
}
```

<!--- CLEAR -->

　Serializable アノテーションでは、クラスのプライマリ・コンストラクタのすべてのパラメータをプロパティにする必要があるため、このクラスはコンパイルできません。簡単な回避策は、クラスのプロパティを持つプライベートなプライマリ・コンストラクタを定義し、必要なコンストラクタをセカンダリ・コンストラクタに変更することです。

```kotlin
@Serializable 
class Project private constructor(val owner: String, val name: String) {
    constructor(path: String) : this(
        owner = path.substringBefore('/'),    
        name = path.substringAfter('/')
    )                        

    val path: String
        get() = "$owner/$name"  
}
```    

　シリアライズはプライベートプライマリコンストラクタで動作し、まだバッキングフィールドのみをシリアライズしています。

```kotlin
fun main() {
    println(Json.encodeToString(Project("kotlin/kotlinx.serialization")))
}
```                                                       

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-02.kt)から取得できます。

　この例では、期待される出力が得られます。

```text 
{"owner":"kotlin","name":"kotlinx.serialization"}
```

<!--- TEST -->

### データの検証

　プロパティを使用せずにプライマリ コンストラクタのパラメータを導入したい場合は、プロパティに格納する前にその値を検証したい場合もあります。シリアライズができるようにするには、プライマリ・コンストラクタのパラメータをプロパティに置き換え、バリデーションを `init { ... }` ブロックに移動します。

```kotlin
@Serializable
class Project(val name: String) {
    init {
        require(name.isNotEmpty()) { "name cannot be empty" }
    }
}
```

　デシリアライズ処理はKotlinの通常のコンストラクタのように動作し、すべての `init` ブロックを呼び出し、デシリアライズの結果として無効なクラスを取得できないようにします。試してみましょう。


```kotlin
fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":""}
    """)
    println(data)
}
```    

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-03.kt)から取得できます。

このコードを実行すると例外が発生します。

```text 
Exception in thread "main" java.lang.IllegalArgumentException: name cannot be empty
```

<!--- TEST LINES_START -->

### オプションのプロパティ

　オブジェクトは、そのプロパティがすべて入力に存在する場合にのみデシリアライズすることができます。例えば、以下のコードを実行します。

```kotlin
@Serializable 
data class Project(val name: String, val language: String)

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization"}
    """)
    println(data)
}
```                                  

> 敢然なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-04.kt)から取得することができます。

　例外を発生させます。

```text
Exception in thread "main" kotlinx.serialization.MissingFieldException: Field 'language' is required, but it was missing
```   

<!--- TEST LINES_START -->

　この問題は、プロパティにデフォルト値を追加することで修正することができます。

```kotlin
@Serializable 
data class Project(val name: String, val language: String = "Kotlin")

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization"}
    """)
    println(data)
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-05.kt)から取得できます。

　これは、`language` プロパティのデフォルト値を指定して以下の出力を生成します。

```text
Project(name=kotlinx.serialization, language=Kotlin)
```   

<!--- TEST -->

### オプションのプロパティイニシャライザの呼び出し

　入力にオプションのプロパティが存在する場合、このプロパティに対応するイニシャライザは呼び出されません。これはパフォーマンスのために設計された機能なので、イニシャライザの副作用に頼らないように注意してください。以下の例を考えてみましょう。

```kotlin
fun computeLanguage(): String {
    println("Computing")
    return "Kotlin"
}

@Serializable 
data class Project(val name: String, val language: String = computeLanguage())
 
fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization","language":"Kotlin"}
    """)
    println(data)
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-06.kt)から取得することができます。

　入力に `language` プロパティが指定されているので、出力には "Computing" という文字列は表示されません。

```text
Project(name=kotlinx.serialization, language=Kotlin)
```   
 
<!--- TEST -->

### 必要なプロパティ

　デフォルト値を持つプロパティは、[`@Required`](https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/-required/index.html)アノテーションを使ってシリアル形式で要求することができます。先ほどの例を変更して、`language` プロパティに `@Required` を指定してみましょう。

```kotlin
@Serializable 
data class Project(val name: String, @Required val language: String = "Kotlin")

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization"}
    """)
    println(data)
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-07.kt)から取得できます。

　以下のような例外が発生します。

```text
Exception in thread "main" kotlinx.serialization.MissingFieldException: Field 'language' is required, but it was missing
```   

<!--- TEST LINES_START -->

### トランジェントプロパティ

　プロパティを [`@Transient`][Transient] アノテーションでマークすることで、シリアライズから除外することができます (これを [kotlin.jvm.Transient](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-transient/) と混同しないようにしてください)。Transientプロパティはデフォルト値を持つ必要があります。

```kotlin
@Serializable 
data class Project(val name: String, @Transient val language: String = "Kotlin")

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization","language":"Kotlin"}
    """)
    println(data)
}
```                                  

> フルコード[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-08.kt)から取得することができます。

　指定された値がデフォルト値と同じであっても、シリアル形式で明示的に値を指定しようとすると、以下のような例外が発生します。

```text
Exception in thread "main" kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 60: Encountered an unknown key 'language'.
Use 'ignoreUnknownKeys = true' in 'Json {}' builder to ignore unknown keys.
```   

<!--- TEST LINES_START -->

> 「ignoreUnknownKeys」の機能については、[Ignoring Unknown Keys](https://qiita.com/guijiu/items/9bcbe7379026d88978da#%E6%9C%AA%E7%9F%A5%E3%81%AE%E3%82%AD%E3%83%BC%E3%82%92%E7%84%A1%E8%A6%96)の項で説明しています。

### デフォルト値はエンコードされない

　JSONではデフォルト値は、あらかじめ設定された状態ではエンコードされません。この動作は、ほとんどの架空ではないシナリオにおいて、このような設定が視覚的な乱雑さを減らし、シリアライズされるデータ量を節約するという事実に基づいています。

```kotlin
@Serializable 
data class Project(val name: String, val language: String = "Kotlin")

fun main() {
    val data = Project("kotlinx.serialization")
    println(Json.encodeToString(data))
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-09.kt)から取得することができます。

　これは以下の出力を生成しますが、その値はデフォルトのものと同じであるため、`language` プロパティを持ちません。

```text
{"name":"kotlinx.serialization"}
```                 

> この動作がJSONに対してどのように設定できるかについては、[Encoding defaults](https://qiita.com/guijiu/items/9bcbe7379026d88978da#%E3%82%A8%E3%83%B3%E3%82%B3%E3%83%BC%E3%83%89%E3%81%AE%E3%83%87%E3%83%95%E3%82%A9%E3%83%AB%E3%83%88%E5%80%A4)のセクションを参照してください。

<!--- TEST -->

### ヌル可能なプロパティ

　ヌル可能なプロパティは Kotlin Serialization でネイティブにサポートされています。

```kotlin
@Serializable
class Project(val name: String, val renamedTo: String? = null)

fun main() {
    val data = Project("kotlinx.serialization")
    println(Json.encodeToString(data))
}
```               

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-10.kt)から取得できます。

　この例では、[デフォルト値がエンコードされていない](https://qiita.com/guijiu/items/4defa057b800a2348607#%E3%83%87%E3%83%95%E3%82%A9%E3%83%AB%E3%83%88%E5%80%A4%E3%81%AF%E3%82%A8%E3%83%B3%E3%82%B3%E3%83%BC%E3%83%89%E3%81%95%E3%82%8C%E3%81%AA%E3%81%84)はで、JSONに `null` をエンコードしません。

```text
{"name":"kotlinx.serialization"}
```     

<!--- TEST -->

### 型安全性の確保

　Kotlin SerializationはKotlinプログラミング言語の型の安全性を強く強制します。具体的には、JSONオブジェクトから `null` の値を、 NULL ではない Kotlin のプロパティ `language` にデコードしてみましょう。


```kotlin
@Serializable 
data class Project(val name: String, val language: String = "Kotlin")

fun main() {
    val data = Json.decodeFromString<Project>("""
        {"name":"kotlinx.serialization","language":null}
    """)
    println(data)
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-11.kt)から取得できます。

　language プロパティがデフォルト値を持っているにもかかわらず、null値を代入しようとするとエラーになります。

```text
Exception in thread "main" kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 52: Expected string literal but 'null' literal was found.
Use 'coerceInputValues = true' in 'Json {}` builder to coerce nulls to default values.
```                    

<!--- TEST LINES_START -->

> サードパーティのJSONをデコードする際に、`null` をデフォルト値に強制することが望まれるかもしれません。これに対応する機能は、[入力値の強制](https://qiita.com/guijiu/items/9bcbe7379026d88978da#%E5%85%A5%E5%8A%9B%E5%80%A4%E3%81%AE%E5%BC%B7%E5%88%B6)のセクションで説明しています。

### 参照されたオブジェクト

　シリアライズ可能なクラスは、そのシリアライズ可能なプロパティで他のクラスを参照することができます。参照されるクラスは `@Serializable` としてもマークされていなければなりません。

```kotlin
@Serializable
class Project(val name: String, val owner: User)

@Serializable
class User(val name: String)

fun main() {
    val owner = User("kotlin")
    val data = Project("kotlinx.serialization", owner)
    println(Json.encodeToString(data))
}
```                                 

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-12.kt)から取得できます。

　JSONにエンコードされると、ネストされたJSONオブジェクトになります。

```text
{"name":"kotlinx.serialization","owner":{"name":"kotlin"}}
```

> シリアライズ不可能なクラスへの参照は、[Transient properties](https://qiita.com/guijiu/items/4defa057b800a2348607#%E3%83%88%E3%83%A9%E3%83%B3%E3%82%B8%E3%82%A7%E3%83%B3%E3%83%88%E3%83%97%E3%83%AD%E3%83%91%E3%83%86%E3%82%A3)としてマークするか、[Serializers](https://qiita.com/guijiu/items/be7fa14c49cb7e3006dd#%E7%AC%AC3%E7%AB%A0-%E3%82%B7%E3%83%AA%E3%82%A2%E3%83%A9%E3%82%A4%E3%82%B6-%E5%8E%9F%E6%96%87)の章で示されているように、カスタムシリアライザを提供することができます。 

<!--- TEST -->


### 繰り返し参照を圧縮しないでください。

　Kotlin Serializationはプレーンデータのエンコードとデコードのために設計されています。オブジェクト参照が繰り返される任意のオブジェクトグラフの再構成はサポートしていません。例えば、同じ `owner` インスタンスを二度参照しているオブジェクトをシリアライズしてみましょう。

```kotlin
@Serializable
class Project(val name: String, val owner: User, val maintainer: User)

@Serializable
class User(val name: String)

fun main() {
    val owner = User("kotlin")
    val data = Project("kotlinx.serialization", owner, owner)
    println(Json.encodeToString(data))
}
```                                 

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-13.kt)から取得できます。

　単純に2回エンコードされた `owner` 値を取得するだけである。

```text
{"name":"kotlinx.serialization","owner":{"name":"kotlin"},"maintainer":{"name":"kotlin"}}
```       

> 円形構造体をシリアライズしようとすると、スタックオーバーフローになります。 [トランジェントプロパティ](#トランジェントプロパティ)を使用して、一部の参照をシリアライズから除外することができます。

<!--- TEST -->

### ジェネリッククラス

　Kotlin の汎用クラスは型ポリモーフィックな振る舞いを提供し、コンパイル時に Kotlin Serialization によって強制されます。例えば、一般的なシリアライズ可能なクラス `Box<T>` を考えてみましょう。

```kotlin
@Serializable
class Box<T>(val contents: T)
```                              

　`Box<T>` クラスは `Int` のような組み込み型や `Project` のようなユーザ定義型と一緒に使うことができます。 

<!--- INCLUDE

@Serializable
data class Project(val name: String, val language: String)
-->

```kotlin
@Serializable
class Data(
    val a: Box<Int>,
    val b: Box<Project>
)

fun main() {
    val data = Data(Box(42), Box(Project("kotlinx.serialization", "Kotlin")))
    println(Json.encodeToString(data))
}
```                                  

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-14.kt)から取得できます。

　JSONで取得する実際の型は、`Box`で指定されたコンパイル時の型パラメータに依存します。

```text 
{"a":{"contents":42},"b":{"contents":{"name":"kotlinx.serialization","language":"Kotlin"}}}
```

<!--- TEST -->

　実際の汎用型がシリアライズできない場合、コンパイル時のエラーが発生します。

### シリアルフィールド名

　エンコードされたepresentation、例ではJSONで使用されるプロパティの名前は、デフォルトではソースコードでの名前と同じです。シリアライズに使われる名前は _serial name_ と呼ばれ、[`@SerialName`][SerialName] アノテーションを使って変更することができます。例えば、`language` プロパティに省略されたシリアル名を指定することができます。

```kotlin
@Serializable
class Project(val name: String, @SerialName("lang") val language: String)

fun main() {
    val data = Project("kotlinx.serialization", "Kotlin")
    println(Json.encodeToString(data))
}
```                                 

> 完全なコードは[こちら](https://github.com/Kotlin/kotlinx.serialization/blob/master/guide/example/example-classes-15.kt)から取得できます。

　これで、JSON出力に `lang` という略称が使われていることがわかりました。

```text
{"name":"kotlinx.serialization","lang":"Kotlin"}
```                   

<!--- TEST -->

---

　次の章では、[ビルトインクラス](https://qiita.com/guijiu/items/036e9169cb6c6a73214f#%E7%AC%AC2%E7%AB%A0-%E3%83%93%E3%83%AB%E3%83%88%E3%82%A4%E3%83%B3%E3%82%AF%E3%83%A9%E3%82%B9%E5%8E%9F%E6%96%87)について説明します。

<!--- MODULE /kotlinx-serialization-core -->
<!--- INDEX kotlinx-serialization-core/kotlinx.serialization -->
[kotlinx.serialization.encodeToString]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/encode-to-string.html
[Serializable]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/-serializable/index.html
[kotlinx.serialization.decodeFromString]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/decode-from-string.html
[Required]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/-required/index.html
[Transient]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/-transient/index.html
[SerialName]: https://kotlin.github.io/kotlinx.serialization/kotlinx-serialization-core/kotlinx-serialization-core/kotlinx.serialization/-serial-name/index.html
<!--- MODULE /kotlinx-serialization-json -->
<!--- INDEX kotlinx-serialization-json/kotlinx.serialization.json -->
<!--- END -->