diff --git a/docs/formats.md b/docs/formats.md
index f95442fa9..8fb6eaef5 100644
--- a/docs/formats.md
+++ b/docs/formats.md
@@ -18,6 +18,9 @@ stable, these are currently experimental features of Kotlin Serialization.
   * [Integer types](#integer-types)
   * [Lists as repeated fields](#lists-as-repeated-fields)
   * [Packed fields](#packed-fields)
+  * [Oneof field (experimental)](#oneof-field-experimental)
+    * [Usage](#usage)
+    * [Alternative](#alternative)
   * [ProtoBuf schema generator (experimental)](#protobuf-schema-generator-experimental)
 * [Properties (experimental)](#properties-experimental)
 * [Custom formats (experimental)](#custom-formats-experimental)
@@ -435,6 +438,106 @@ Per the standard packed fields can only be used on primitive numeric types. The
 Per the [format description](https://developers.google.com/protocol-buffers/docs/encoding#packed) the parser ignores
 the annotation, but rather reads list in either packed or repeated format.
 
+### Oneof field (experimental)
+
+Kotlin Serialization `ProtoBuf` format supports [oneof](https://protobuf.dev/programming-guides/proto2/#oneof) fields
+basing on the [Polymorphism](polymorphism.md) functionality.
+
+#### Usage
+
+Given a protobuf message defined like:
+
+```proto
+message Data {
+    required string name = 1;
+    oneof phone {
+        string home_phone = 2;
+        string work_phone = 3;
+    }
+}
+```
+
+You can define a kotlin class semantically equal to this message by following these steps:
+
+* Declare a sealed interface or abstract class, to represent of the `oneof` group, called *the oneof interface*. In our example, oneof interface is `IPhoneType`.
+* Declare a Kotlin class as usual to represent the whole message (`class Data` in our example). In this class, add the property with oneof interface type, annotated with `@ProtoOneOf`. Do not use `@ProtoNumber` for that property.
+* Declare subclasses for oneof interface, one per each oneof group element. Each class must have **exactly one property** with the corresponding oneof element type. In our example, these classes are `HomePhone` and `WorkPhone`.
+* Annotate properties in subclasses with `@ProtoNumber`, according to original `oneof` definition. In our example, `val number: String` in `HomePhone` has `@ProtoNumber(2)` annotation, because of field `string home_phone = 2;` in `oneof phone`.
+
+<!--- INCLUDE
+import kotlinx.serialization.*
+import kotlinx.serialization.protobuf.*
+-->
+
+```kotlin
+// The outer class
+@Serializable
+data class Data(
+    @ProtoNumber(1) val name: String,
+    @ProtoOneOf val phone: IPhoneType?,
+)
+
+// The oneof interface
+@Serializable sealed interface IPhoneType
+
+// Message holder for home_phone
+@Serializable @JvmInline value class HomePhone(@ProtoNumber(2) val number: String): IPhoneType
+
+// Message holder for work_phone. Can also be a value class, but we leave it as `data` to demonstrate that both variants can be used.
+@Serializable data class WorkPhone(@ProtoNumber(3) val number: String): IPhoneType
+
+fun main() {
+  val dataTom = Data("Tom", HomePhone("123"))
+  val stringTom = ProtoBuf.encodeToHexString(dataTom)
+  val dataJerry = Data("Jerry", WorkPhone("789"))
+  val stringJerry = ProtoBuf.encodeToHexString(dataJerry)
+  println(stringTom)
+  println(stringJerry)
+  println(ProtoBuf.decodeFromHexString<Data>(stringTom))
+  println(ProtoBuf.decodeFromHexString<Data>(stringJerry))
+}
+```
+
+> You can get the full code [here](../guide/example/example-formats-08.kt).
+
+```text
+0a03546f6d1203313233
+0a054a657272791a03373839
+Data(name=Tom, phone=HomePhone(number=123))
+Data(name=Jerry, phone=WorkPhone(number=789))
+```
+
+<!--- TEST -->
+
+In [ProtoBuf diagnostic mode](https://protogen.marcgravell.com/decode) the first 2 lines in the output are equivalent to
+
+```
+Field #1: 0A String Length = 3, Hex = 03, UTF8 = "Tom" Field #2: 12 String Length = 3, Hex = 03, UTF8 = "123"
+Field #1: 0A String Length = 5, Hex = 05, UTF8 = "Jerry" Field #3: 1A String Length = 3, Hex = 03, UTF8 = "789"
+```
+
+You should note that each group of `oneof` types should be tied to exactly one data class, and it is better not to reuse it in
+another data class. Otherwise, you may get id conflicts or `IllegalArgumentException` in runtime.
+
+#### Alternative
+
+You don't always need to apply the `@ProtoOneOf` form in your class for messages with `oneof` fields, if this class is only used for deserialization.
+
+For example, the following class:
+
+```
+@Serializable  
+data class Data2(  
+    @ProtoNumber(1) val name: String,  
+    @ProtoNumber(2) val homeNumber: String? = null,  
+    @ProtoNumber(3) val workNumber: String? = null,  
+)  
+```
+
+is also compatible with the `message Data` given above, which means the same input can be deserialized into it instead of `Data` — in case you don't want to deal with sealed hierarchies.
+
+But please note that there are no exclusivity checks. This means that if an instance of `Data2` has both (or none) `homeNumber` and `workNumber` as non-null values and is serialized to protobuf, it no longer complies with the original schema. If you send such data to another parser, one of the fields may be omitted, leading to an unknown issue.
+
 ### ProtoBuf schema generator (experimental)
 
 As mentioned above, when working with protocol buffers you usually use a ".proto" file and a code generator for your
@@ -467,7 +570,7 @@ fun main() {
   println(schemas)
 }
 ```
-> You can get the full code [here](../guide/example/example-formats-08.kt).
+> You can get the full code [here](../guide/example/example-formats-09.kt).
 
 Which would output as follows.
 
@@ -475,7 +578,7 @@ Which would output as follows.
 syntax = "proto2";
 
 
-// serial name 'example.exampleFormats08.SampleData'
+// serial name 'example.exampleFormats09.SampleData'
 message SampleData {
   required int64 amount = 1;
   optional string description = 2;
@@ -519,7 +622,7 @@ fun main() {
 }
 ```      
 
-> You can get the full code [here](../guide/example/example-formats-09.kt).
+> You can get the full code [here](../guide/example/example-formats-10.kt).
 
 The resulting map has dot-separated keys representing keys of the nested objects.
 
@@ -599,7 +702,7 @@ fun main() {
 }
 ```                                    
 
-> You can get the full code [here](../guide/example/example-formats-10.kt).
+> You can get the full code [here](../guide/example/example-formats-11.kt).
 
 As a result, we got all the primitive values in our object graph visited and put into a list
 in _serial_ order.
@@ -701,7 +804,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-formats-11.kt).
+> You can get the full code [here](../guide/example/example-formats-12.kt).
 
 Now we can convert a list of primitives back to an object tree.
 
@@ -792,7 +895,7 @@ fun main() {
 }
 -->
 
-> You can get the full code [here](../guide/example/example-formats-12.kt).
+> You can get the full code [here](../guide/example/example-formats-13.kt).
 
 <!--- TEST 
 [kotlinx.serialization, kotlin, 9000]
@@ -899,7 +1002,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-formats-13.kt).
+> You can get the full code [here](../guide/example/example-formats-14.kt).
 
 We see the size of the list added to the result, letting the decoder know where to stop. 
 
@@ -1011,7 +1114,7 @@ fun main() {
 
 ```
 
-> You can get the full code [here](../guide/example/example-formats-14.kt).
+> You can get the full code [here](../guide/example/example-formats-15.kt).
 
 In the output we see how not-null`!!` and `NULL` marks are used.
 
@@ -1139,7 +1242,7 @@ fun main() {
 }
 ```
               
-> You can get the full code [here](../guide/example/example-formats-15.kt).
+> You can get the full code [here](../guide/example/example-formats-16.kt).
 
 As we can see, the result is a dense binary format that only contains the data that is being serialized. 
 It can be easily tweaked for any kind of domain-specific compact encoding.
@@ -1333,7 +1436,7 @@ fun main() {
 }
 ```
               
-> You can get the full code [here](../guide/example/example-formats-16.kt).
+> You can get the full code [here](../guide/example/example-formats-17.kt).
 
 As we can see, our custom byte array format is being used, with the compact encoding of its size in one byte. 
 
diff --git a/docs/serialization-guide.md b/docs/serialization-guide.md
index 5743d4cfd..acd654b35 100644
--- a/docs/serialization-guide.md
+++ b/docs/serialization-guide.md
@@ -152,6 +152,9 @@ Once the project is set up, we can start serializing some classes.
   * <a name='integer-types'></a>[Integer types](formats.md#integer-types)
   * <a name='lists-as-repeated-fields'></a>[Lists as repeated fields](formats.md#lists-as-repeated-fields)
   * <a name='packed-fields'></a>[Packed fields](formats.md#packed-fields)
+  * <a name='oneof-field-experimental'></a>[Oneof field (experimental)](formats.md#oneof-field-experimental)
+    * <a name='usage'></a>[Usage](formats.md#usage)
+    * <a name='alternative'></a>[Alternative](formats.md#alternative)
   * <a name='protobuf-schema-generator-experimental'></a>[ProtoBuf schema generator (experimental)](formats.md#protobuf-schema-generator-experimental)
 * <a name='properties-experimental'></a>[Properties (experimental)](formats.md#properties-experimental)
 * <a name='custom-formats-experimental'></a>[Custom formats (experimental)](formats.md#custom-formats-experimental)
diff --git a/formats/protobuf/api/kotlinx-serialization-protobuf.api b/formats/protobuf/api/kotlinx-serialization-protobuf.api
index c0d61b9f1..682e4bf16 100644
--- a/formats/protobuf/api/kotlinx-serialization-protobuf.api
+++ b/formats/protobuf/api/kotlinx-serialization-protobuf.api
@@ -39,6 +39,13 @@ public synthetic class kotlinx/serialization/protobuf/ProtoNumber$Impl : kotlinx
 	public final synthetic fun number ()I
 }
 
+public abstract interface annotation class kotlinx/serialization/protobuf/ProtoOneOf : java/lang/annotation/Annotation {
+}
+
+public synthetic class kotlinx/serialization/protobuf/ProtoOneOf$Impl : kotlinx/serialization/protobuf/ProtoOneOf {
+	public fun <init> ()V
+}
+
 public abstract interface annotation class kotlinx/serialization/protobuf/ProtoPacked : java/lang/annotation/Annotation {
 }
 
diff --git a/formats/protobuf/api/kotlinx-serialization-protobuf.klib.api b/formats/protobuf/api/kotlinx-serialization-protobuf.klib.api
index 6664ff7e6..484694d89 100644
--- a/formats/protobuf/api/kotlinx-serialization-protobuf.klib.api
+++ b/formats/protobuf/api/kotlinx-serialization-protobuf.klib.api
@@ -33,6 +33,9 @@ open annotation class kotlinx.serialization.protobuf/ProtoNumber : kotlin/Annota
     final val number // kotlinx.serialization.protobuf/ProtoNumber.number|{}number[0]
         final fun <get-number>(): kotlin/Int // kotlinx.serialization.protobuf/ProtoNumber.number.<get-number>|<get-number>(){}[0]
 }
+open annotation class kotlinx.serialization.protobuf/ProtoOneOf : kotlin/Annotation { // kotlinx.serialization.protobuf/ProtoOneOf|null[0]
+    constructor <init>() // kotlinx.serialization.protobuf/ProtoOneOf.<init>|<init>(){}[0]
+}
 open annotation class kotlinx.serialization.protobuf/ProtoPacked : kotlin/Annotation { // kotlinx.serialization.protobuf/ProtoPacked|null[0]
     constructor <init>() // kotlinx.serialization.protobuf/ProtoPacked.<init>|<init>(){}[0]
 }
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/ProtoTypes.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/ProtoTypes.kt
index 109ffb830..e673f16f2 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/ProtoTypes.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/ProtoTypes.kt
@@ -53,3 +53,14 @@ public annotation class ProtoType(public val type: ProtoIntegerType)
 @Target(AnnotationTarget.PROPERTY)
 @ExperimentalSerializationApi
 public annotation class ProtoPacked
+
+/**
+ * Instructs that a particular property should be written as an [oneof](https://protobuf.dev/programming-guides/proto2/#oneof).
+ *
+ * The type of the annotated property should be polymorphic (interface or abstract class).
+ * Inheritors of this type would represent `one of` choices, and each inheritor should have exactly one property, annotated with [ProtoNumber].
+ */
+@SerialInfo
+@Target(AnnotationTarget.PROPERTY)
+@ExperimentalSerializationApi
+public annotation class ProtoOneOf
\ No newline at end of file
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/Helpers.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/Helpers.kt
index 59533db0f..07efb47c4 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/Helpers.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/Helpers.kt
@@ -8,6 +8,7 @@ package kotlinx.serialization.protobuf.internal
 
 import kotlinx.serialization.*
 import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.modules.*
 import kotlinx.serialization.protobuf.*
 
 internal typealias ProtoDesc = Long
@@ -16,19 +17,17 @@ internal const val i64 = 1
 internal const val SIZE_DELIMITED = 2
 internal const val i32 = 5
 
-private const val INTTYPEMASK = (Int.MAX_VALUE.toLong() shr 1) shl 33
-private const val PACKEDMASK = 1L shl 32
+internal const val ID_HOLDER_ONE_OF = -2
 
-@Suppress("NOTHING_TO_INLINE")
-internal inline fun ProtoDesc(protoId: Int, type: ProtoIntegerType, packed: Boolean): ProtoDesc {
-    val packedBits = if (packed) 1L shl 32 else 0L
-    val signature = type.signature or packedBits
-    return signature or protoId.toLong()
-}
+private const val ONEOFMASK = 1L shl 36
+private const val INTTYPEMASK = 3L shl 33
+private const val PACKEDMASK = 1L shl 32
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun ProtoDesc(protoId: Int, type: ProtoIntegerType): ProtoDesc {
-    return type.signature or protoId.toLong()
+internal inline fun ProtoDesc(protoId: Int, type: ProtoIntegerType, packed: Boolean = false, oneOf: Boolean = false): ProtoDesc {
+    val packedBits = if (packed) PACKEDMASK else 0L
+    val oneOfBits = if (oneOf) ONEOFMASK else 0L
+    return packedBits or oneOfBits or type.signature or protoId.toLong()
 }
 
 internal inline val ProtoDesc.protoId: Int get() = (this and Int.MAX_VALUE.toLong()).toInt()
@@ -51,11 +50,19 @@ internal val SerialDescriptor.isPackable: Boolean
 internal val ProtoDesc.isPacked: Boolean
     get() = (this and PACKEDMASK) != 0L
 
+internal val ProtoDesc.isOneOf: Boolean
+    get() = (this and ONEOFMASK) != 0L
+
+internal fun ProtoDesc.overrideId(protoId: Int): ProtoDesc {
+    return this and (0xFFFFFFF00000000L) or protoId.toLong()
+}
+
 internal fun SerialDescriptor.extractParameters(index: Int): ProtoDesc {
     val annotations = getElementAnnotations(index)
     var protoId: Int = index + 1
     var format: ProtoIntegerType = ProtoIntegerType.DEFAULT
     var protoPacked = false
+    var isOneOf = false
 
     for (i in annotations.indices) { // Allocation-friendly loop
         val annotation = annotations[i]
@@ -65,23 +72,61 @@ internal fun SerialDescriptor.extractParameters(index: Int): ProtoDesc {
             format = annotation.type
         } else if (annotation is ProtoPacked) {
             protoPacked = true
+        } else if (annotation is ProtoOneOf) {
+            isOneOf = true
         }
     }
-    return ProtoDesc(protoId, format, protoPacked)
+    if (isOneOf) {
+        // reset protoId to index-based for oneOf field,
+        // Decoder will restore the real proto id then from [ProtobufDecoder.index2IdMap]
+        // See [kotlinx.serialization.protobuf.internal.ProtobufDecoder.decodeElementIndex] for detail
+        protoId = index + 1
+    }
+    return ProtoDesc(protoId, format, protoPacked, isOneOf)
 }
 
+/**
+ * Get the proto id from the descriptor of [index] element,
+ * or return [ID_HOLDER_ONE_OF] if such element is marked with [ProtoOneOf]
+ */
 internal fun extractProtoId(descriptor: SerialDescriptor, index: Int, zeroBasedDefault: Boolean): Int {
     val annotations = descriptor.getElementAnnotations(index)
+    var result = if (zeroBasedDefault) index else index + 1
     for (i in annotations.indices) { // Allocation-friendly loop
         val annotation = annotations[i]
-        if (annotation is ProtoNumber) {
-            return annotation.number
+        if (annotation is ProtoOneOf) {
+            // Fast return for one of field
+            return ID_HOLDER_ONE_OF
+        } else if (annotation is ProtoNumber) {
+            result = annotation.number
         }
     }
-    return if (zeroBasedDefault) index else index + 1
+    return result
 }
 
 internal class ProtobufDecodingException(message: String) : SerializationException(message)
 
 internal expect fun Int.reverseBytes(): Int
 internal expect fun Long.reverseBytes(): Long
+
+
+internal fun SerialDescriptor.getAllOneOfSerializerOfField(
+    serializersModule: SerializersModule,
+): List<SerialDescriptor> {
+    return when (this.kind) {
+        PolymorphicKind.OPEN -> serializersModule.getPolymorphicDescriptors(this)
+        PolymorphicKind.SEALED -> getElementDescriptor(1).elementDescriptors.toList()
+        else -> throw IllegalArgumentException("Class ${this.serialName} should be abstract or sealed or interface to be used as @ProtoOneOf property.")
+    }.onEach { desc ->
+        if (desc.getElementAnnotations(0).none { anno -> anno is ProtoNumber }) {
+            throw IllegalArgumentException("${desc.serialName} implementing oneOf type ${this.serialName} should have @ProtoNumber annotation in its single property.")
+        }
+    }
+}
+
+internal fun SerialDescriptor.getActualOneOfSerializer(
+    serializersModule: SerializersModule,
+    protoId: Int
+): SerialDescriptor? {
+    return getAllOneOfSerializerOfField(serializersModule).find { it.extractParameters(0).protoId == protoId }
+}
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufDecoding.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufDecoding.kt
index 861e2bf35..55549f4a1 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufDecoding.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufDecoding.kt
@@ -28,6 +28,9 @@ internal open class ProtobufDecoder(
     private var indexCache: IntArray? = null
     private var sparseIndexCache: MutableMap<Int, Int>? = null
 
+    // Index -> proto id for oneof element. An oneof element of certain index may refer to different proto id in runtime.
+    private var index2IdMap: MutableMap<Int, Int>? = null
+
     private var nullValue: Boolean = false
     private val elementMarker = ElementMarker(descriptor, ::readIfAbsent)
 
@@ -46,7 +49,10 @@ internal open class ProtobufDecoder(
             val cache = IntArray(elements + 1)
             for (i in 0 until elements) {
                 val protoId = extractProtoId(descriptor, i, false)
-                if (protoId <= elements) {
+                // If any element is marked as ProtoOneOf,
+                // the fast path is not applicable
+                // because it will contain more id than elements
+                if (protoId <= elements && protoId != ID_HOLDER_ONE_OF) {
                     cache[protoId] = i
                 } else {
                     return populateCacheMap(descriptor, elements)
@@ -59,22 +65,39 @@ internal open class ProtobufDecoder(
     }
 
     private fun populateCacheMap(descriptor: SerialDescriptor, elements: Int) {
-        val map = HashMap<Int, Int>(elements)
+        val map = HashMap<Int, Int>(elements, 1f)
+        var oneOfCount = 0
         for (i in 0 until elements) {
-            map[extractProtoId(descriptor, i, false)] = i
+            val id = extractProtoId(descriptor, i, false)
+            if (id == ID_HOLDER_ONE_OF) {
+                descriptor.getElementDescriptor(i)
+                    .getAllOneOfSerializerOfField(serializersModule)
+                    .map { it.extractParameters(0).protoId }
+                    .forEach { map.putProtoId(it, i) }
+                oneOfCount ++
+            } else {
+                map.putProtoId(extractProtoId(descriptor, i, false),  i)
+            }
+        }
+        if (oneOfCount > 0) {
+            index2IdMap = HashMap(oneOfCount, 1f)
         }
         sparseIndexCache = map
     }
 
-    private fun getIndexByTag(protoTag: Int): Int {
+    private fun MutableMap<Int, Int>.putProtoId(protoId: Int, index: Int) {
+        put(protoId, index)
+    }
+
+    private fun getIndexByNum(protoNum: Int): Int {
         val array = indexCache
         if (array != null) {
-            return array.getOrElse(protoTag) { -1 }
+            return array.getOrElse(protoNum) { -1 }
         }
-        return getIndexByTagSlowPath(protoTag)
+        return getIndexByNumSlowPath(protoNum)
     }
 
-    private fun getIndexByTagSlowPath(
+    private fun getIndexByNumSlowPath(
         protoTag: Int
     ): Int = sparseIndexCache!!.getOrElse(protoTag) { -1 }
 
@@ -121,6 +144,15 @@ internal open class ProtobufDecoder(
                 val tag = currentTagOrDefault
                 // Do not create redundant copy
                 if (tag == MISSING_TAG && this.descriptor == descriptor) return this
+                if (tag.isOneOf) {
+                    // If a tag is annotated as oneof
+                    // [tag.protoId] here is overwritten with index-based default id in
+                    // [kotlinx.serialization.protobuf.internal.HelpersKt.extractParameters]
+                    // and restored the real id from index2IdMap, set by [decodeElementIndex]
+                    val rawIndex = tag.protoId - 1
+                    val restoredTag = index2IdMap?.get(rawIndex)?.let { tag.overrideId(it) } ?: tag
+                    return OneOfPolymorphicReader(proto, reader, restoredTag, descriptor)
+                }
                 return ProtobufDecoder(proto, makeDelimited(reader, tag), descriptor)
             }
             StructureKind.MAP -> MapEntryReader(proto, makeDelimitedForced(reader, currentTagOrDefault), currentTagOrDefault, descriptor)
@@ -225,10 +257,21 @@ internal open class ProtobufDecoder(
             if (protoId == -1) { // EOF
                 return elementMarker.nextUnmarkedIndex()
             }
-            val index = getIndexByTag(protoId)
+            val index = getIndexByNum(protoId)
             if (index == -1) { // not found
                 reader.skipElement()
             } else {
+                if (descriptor.extractParameters(index).isOneOf) {
+                    /**
+                     * While decoding message with one-of field,
+                     * the proto id read from wire data cannot be easily found
+                     * in the properties of this type,
+                     * So the index of this one-of property and the id read from the wire
+                     * are saved in this map, then restored in [beginStructure]
+                     * and passed to [OneOfPolymorphicReader] to get the actual deserializer.
+                     */
+                    index2IdMap?.put(index, protoId)
+                }
                 elementMarker.mark(index)
                 return index
             }
@@ -331,6 +374,97 @@ private class MapEntryReader(
         else ProtoDesc(2, (parentTag.integerType))
 }
 
+private class OneOfPolymorphicReader(
+    proto: ProtoBuf,
+    decoder: ProtobufReader,
+    private val parentTag: ProtoDesc,
+    descriptor: SerialDescriptor
+) : ProtobufDecoder(proto, decoder, descriptor) {
+    private var serialNameDecoded = false
+    private var contentDecoded = false
+    override fun SerialDescriptor.getTag(index: Int): ProtoDesc = if (index == 0) {
+        POLYMORPHIC_NAME_TAG
+    } else {
+        extractParameters(0)
+    }
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder {
+        return if (descriptor == this.descriptor) {
+            this
+        } else {
+            OneOfElementReader(proto, reader, descriptor)
+        }
+    }
+
+    override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
+        if (!serialNameDecoded) {
+            serialNameDecoded = true
+            return 0
+        } else if (!contentDecoded) {
+            contentDecoded = true
+            return 1
+        } else {
+            return CompositeDecoder.DECODE_DONE
+        }
+    }
+
+    override fun decodeTaggedString(tag: ProtoDesc): String = if (tag == POLYMORPHIC_NAME_TAG) {
+        // This exception will neven be thrown
+        // Subclass of oneof-field without matching ProtoNum annotated will be skipped in outer [decodeElementIndex]
+        // and raise a [MissingFieldException]
+        descriptor.getActualOneOfSerializer(serializersModule, parentTag.protoId)?.serialName ?: throw SerializationException(
+            "Cannot find a subclass of ${descriptor.serialName} annotated with @ProtoNumber(${parentTag.protoId})."
+        )
+    } else {
+        super.decodeTaggedString(tag)
+    }
+}
+
+private class OneOfElementReader(
+    proto: ProtoBuf,
+    decoder: ProtobufReader,
+    descriptor: SerialDescriptor
+) : ProtobufDecoder(proto, decoder, descriptor) {
+    private val classId: Int
+    init {
+        require(descriptor.elementsCount == 1) {
+            "Implementation of oneOf type ${descriptor.serialName} should contain only 1 element, but get ${descriptor.elementsCount}"
+        }
+        val protoNumber = descriptor.getElementAnnotations(0).filterIsInstance<ProtoNumber>().singleOrNull()
+        require(protoNumber != null) {
+            "Implementation of oneOf type ${descriptor.serialName} should have @ProtoNumber annotation"
+        }
+        classId = protoNumber.number
+    }
+
+    private var contentDecoded: Boolean = false
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder {
+        return when(descriptor.kind) {
+            StructureKind.CLASS, StructureKind.OBJECT, is PolymorphicKind -> {
+                val tag = currentTagOrDefault
+                // Do not create redundant copy
+                if (tag == MISSING_TAG && this.descriptor == descriptor) return this
+                if (tag.isOneOf) throw SerializationException("An oneof element cannot be directly child of another oneof element")
+                ProtobufDecoder(proto, makeDelimited(reader, tag), descriptor)
+            }
+            else -> {
+                throw SerializationException("Type ${descriptor.kind} cannot be directly child of oneof element")
+            }
+        }
+    }
+
+    override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
+        return if (contentDecoded) {
+            -1
+        }
+        else {
+            contentDecoded = true
+            0
+        }
+    }
+}
+
 private fun makeDelimited(decoder: ProtobufReader, parentTag: ProtoDesc): ProtobufReader {
     val tagless = parentTag == MISSING_TAG
     val input = if (tagless) decoder.objectTaglessInput() else decoder.objectInput()
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufEncoding.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufEncoding.kt
index fab7a09df..b7d5dd28e 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufEncoding.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufEncoding.kt
@@ -60,9 +60,15 @@ internal open class ProtobufEncoder(
         }
         StructureKind.CLASS, StructureKind.OBJECT, is PolymorphicKind -> {
             val tag = currentTagOrDefault
-            if (tag == MISSING_TAG && descriptor == this.descriptor) this
-            else ObjectEncoder(proto, currentTagOrDefault, writer, descriptor = descriptor)
+            if (tag == MISSING_TAG && descriptor == this.descriptor) {
+                this
+            } else if (tag.isOneOf) {
+                OneOfPolymorphicEncoder(proto = proto, parentWriter = writer, descriptor = descriptor)
+            } else {
+                ObjectEncoder(proto, currentTagOrDefault, writer, descriptor = descriptor)
+            }
         }
+
         StructureKind.MAP -> MapRepeatedEncoder(proto, currentTagOrDefault, writer, descriptor)
         else -> throw SerializationException("This serial kind is not supported as structure: $descriptor")
     }
@@ -117,11 +123,13 @@ internal open class ProtobufEncoder(
         enumDescriptor: SerialDescriptor,
         ordinal: Int
     ) {
+        // An enum element will never be one-of field
+        val id = extractProtoId(enumDescriptor, ordinal, zeroBasedDefault = true)
         if (tag == MISSING_TAG) {
-            writer.writeInt(extractProtoId(enumDescriptor, ordinal, zeroBasedDefault = true))
+            writer.writeInt(id)
         } else {
             writer.writeInt(
-                extractProtoId(enumDescriptor, ordinal, zeroBasedDefault = true),
+                id,
                 tag.protoId,
                 ProtoIntegerType.DEFAULT
             )
@@ -151,7 +159,7 @@ internal open class ProtobufEncoder(
     private fun <T> serializeMap(serializer: SerializationStrategy<T>, value: T) {
         // encode maps as collection of map entries, not merged collection of key-values
         val casted = (serializer as MapLikeSerializer<Any?, Any?, T, *>)
-        val mapEntrySerial = kotlinx.serialization.builtins.MapEntrySerializer(casted.keySerializer, casted.valueSerializer)
+        val mapEntrySerial = MapEntrySerializer(casted.keySerializer, casted.valueSerializer)
         SetSerializer(mapEntrySerial).serialize(this, (value as Map<*, *>).entries)
     }
 }
@@ -173,6 +181,78 @@ private open class ObjectEncoder(
     }
 }
 
+/**
+ * When writing a one-of element with polymorphic serializer,
+ * use [OneOfPolymorphicEncoder] to skip the first element of type name,
+ * and then dispatch to [OneOfElementEncoder] when calling [beginStructure]
+ * to write the content value, with ProtoNumber overridden by class annotation,
+ * directly back to the output stream.
+ */
+private class OneOfPolymorphicEncoder(
+    proto: ProtoBuf,
+    private val parentWriter: ProtobufWriter,
+    descriptor: SerialDescriptor
+) : ProtobufEncoder(proto, parentWriter, descriptor) {
+
+    init {
+        require(descriptor.kind is PolymorphicKind) {
+            "The serializer of one of type ${descriptor.serialName} should be using generic polymorphic serializer, but got ${descriptor.kind}."
+        }
+    }
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
+        return if (descriptor == this.descriptor) {
+            this
+        } else {
+            OneOfElementEncoder(
+                proto = proto,
+                parentWriter = parentWriter,
+                descriptor = descriptor
+            )
+        }
+    }
+
+    override fun encodeInline(descriptor: SerialDescriptor): Encoder {
+        return encodeTaggedInline(popTag().overrideId(descriptor.extractParameters(0).protoId), descriptor)
+    }
+
+    override fun encodeTaggedString(tag: ProtoDesc, value: String) {
+        // the first element with type string is the discriminator of polymorphic serializer with class name
+        // just ignore it
+        if (tag != POLYMORPHIC_NAME_TAG) {
+            super.encodeTaggedString(tag, value)
+        }
+    }
+
+    override fun SerialDescriptor.getTag(index: Int) = when (index) {
+        // 0 for discriminator
+        0 -> POLYMORPHIC_NAME_TAG
+        1 -> extractParameters(index)
+        else -> throw SerializationException("Unsupported index: $index in a oneOf type $serialName, which should be using generic polymorphic serializer")
+    }
+}
+
+/**
+ * A helper encoder for one-of element to write the content value,
+ * with ProtoNumber overridden by class annotation,
+ * directly back to the output stream.
+ */
+private class OneOfElementEncoder(
+    proto: ProtoBuf,
+    parentWriter: ProtobufWriter,
+    descriptor: SerialDescriptor
+) : ProtobufEncoder(proto, parentWriter, descriptor) {
+    init {
+        require(descriptor.elementsCount == 1) {
+            "Implementation of oneOf type ${descriptor.serialName} should contain only 1 element, but get ${descriptor.elementsCount}"
+        }
+        val protoNumber = descriptor.getElementAnnotations(0).filterIsInstance<ProtoNumber>().singleOrNull()
+        require(protoNumber != null) {
+            "Implementation of oneOf type ${descriptor.serialName} should have @ProtoNumber annotation"
+        }
+    }
+}
+
 private class MapRepeatedEncoder(
     proto: ProtoBuf,
     parentTag: ProtoDesc,
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufTaggedBase.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufTaggedBase.kt
index 5c0164359..ffa9f4794 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufTaggedBase.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/internal/ProtobufTaggedBase.kt
@@ -14,6 +14,15 @@ import kotlin.jvm.*
  */
 internal const val MISSING_TAG = 19_500L
 
+/**
+ * Tag indicating that now is handling the first element of polymorphic serializer,
+ * which is the serial name that should match the class name.
+ *
+ * In oneof element, such element should be ignored.
+ */
+internal const val POLYMORPHIC_NAME_TAG: ProtoDesc = 19501
+
+
 internal abstract class ProtobufTaggedBase {
     private var tagsStack = LongArray(8)
     @JvmField
diff --git a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/schema/ProtoBufSchemaGenerator.kt b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/schema/ProtoBufSchemaGenerator.kt
index 4f4ca9c42..e4826bbbb 100644
--- a/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/schema/ProtoBufSchemaGenerator.kt
+++ b/formats/protobuf/commonMain/src/kotlinx/serialization/protobuf/schema/ProtoBufSchemaGenerator.kt
@@ -167,55 +167,109 @@ public object ProtoBufSchemaGenerator {
 
         val usedNumbers: MutableSet<Int> = mutableSetOf()
         val nestedTypes = mutableListOf<TypeDefinition>()
-        for (index in 0 until messageDescriptor.elementsCount) {
-            val fieldName = messageDescriptor.getElementName(index)
+        generateMessageField(messageName, messageType, nestedTypes, usedNumbers)
+        appendLine('}')
+
+        return nestedTypes
+    }
+
+    private fun StringBuilder.generateMessageField(
+        messageName: String,
+        parentType: TypeDefinition,
+        nestedTypes: MutableList<TypeDefinition>,
+        usedNumbers: MutableSet<Int>,
+        counts: Int = parentType.descriptor.elementsCount,
+        getAnnotations: (Int) -> List<Annotation> = { parentType.descriptor.getElementAnnotations(it) },
+        getChildType: (Int) -> TypeDefinition = { parentType.descriptor.getElementDescriptor(it).let(::TypeDefinition) },
+        getChildNumber: (Int) -> Int = { parentType.descriptor.getElementAnnotations(it).filterIsInstance<ProtoNumber>().singleOrNull()?.number ?: (it + 1) },
+        getChildName: (Int) -> String = { parentType.descriptor.getElementName(it) },
+        inOneOfStruct: Boolean = false,
+    ) {
+        val messageDescriptor = parentType.descriptor
+        for (index in 0 until counts) {
+            val fieldName = getChildName(index)
             fieldName.checkIsValidIdentifier {
-                "Invalid name of the field '$fieldName' in message '$messageName' for class with serial " +
-                        "name '${messageDescriptor.serialName}'"
+                "Invalid name of the field '$fieldName' in ${if (inOneOfStruct) "oneof" else ""} message '$messageName' for class with serial " +
+                    "name '${messageDescriptor.serialName}'"
             }
 
-            val fieldDescriptor = messageDescriptor.getElementDescriptor(index)
+            val fieldType = getChildType(index)
+            val fieldDescriptor = fieldType.descriptor
 
-            val isList = fieldDescriptor.isProtobufRepeated
-
-            nestedTypes += when {
-                fieldDescriptor.isProtobufNamedType -> generateNamedType(messageType, index)
-                isList -> generateListType(messageType, index)
-                fieldDescriptor.isProtobufMap -> generateMapType(messageType, index)
-                else -> throw IllegalStateException(
-                    "Unprocessed message field type with serial name " +
+            val number = getChildNumber(index)
+            if (messageDescriptor.isChildOneOfMessage(index)) {
+                require(!inOneOfStruct) {
+                    "Cannot have nested oneof in oneof struct: ${messageName}.$fieldName"
+                }
+                val subDescriptor = fieldDescriptor.getElementDescriptor(1).elementDescriptors.toList()
+                append("  ").append("oneof").append(' ').append(fieldName).appendLine(" {")
+                subDescriptor.forEach { desc ->
+                    require(desc.elementsCount == 1) {
+                        "Implementation of oneOf type ${desc.serialName} should contain only 1 element, but get ${desc.elementsCount}"
+                    }
+                    generateMessageField(
+                        messageName = messageName,
+                        parentType = TypeDefinition(desc),
+                        nestedTypes = nestedTypes,
+                        usedNumbers = usedNumbers,
+                        counts = desc.elementsCount,
+                        getAnnotations = { desc.annotations },
+                        getChildType = { desc.elementDescriptors.single().let(::TypeDefinition) },
+                        getChildNumber = { desc.getElementAnnotations(0).filterIsInstance<ProtoNumber>().singleOrNull()?.number ?: (it + 1) },
+                        getChildName = { desc.getElementName(0) },
+                        inOneOfStruct = true,
+                    )
+                }
+                appendLine("  }")
+            } else {
+                val annotations = getAnnotations(index)
+
+                val isList = fieldDescriptor.isProtobufRepeated
+
+                nestedTypes += when {
+                    fieldDescriptor.isProtobufNamedType -> generateNamedType(
+                        fieldDescriptor = messageDescriptor.getElementDescriptor(index),
+                        annotations = messageDescriptor.getElementAnnotations(index),
+                        isSealedPolymorphic = messageDescriptor.isSealedPolymorphic && index == 1,
+                        isOptional = messageDescriptor.isElementOptional(index),
+                        inOneOfStruct = inOneOfStruct,
+                        indent = if (inOneOfStruct) 2 else 1,
+                    )
+                    isList -> generateListType(parentType, index)
+                    fieldDescriptor.isProtobufMap -> generateMapType(parentType, index)
+                    else -> throw IllegalStateException(
+                        "Unprocessed message field type with serial name " +
                             "'${fieldDescriptor.serialName}' and kind '${fieldDescriptor.kind}'"
-                )
-            }
-
+                    )
+                }
+                if (!usedNumbers.add(number)) {
+                    throw IllegalArgumentException("Field number $number is repeated in the class with serial name ${messageDescriptor.serialName}")
+                }
 
-            val annotations = messageDescriptor.getElementAnnotations(index)
-            val number = annotations.filterIsInstance<ProtoNumber>().singleOrNull()?.number ?: (index + 1)
-            if (!usedNumbers.add(number)) {
-                throw IllegalArgumentException("Field number $number is repeated in the class with serial name ${messageDescriptor.serialName}")
-            }
+                append(' ').append(fieldName).append(" = ").append(number)
 
-            append(' ').append(fieldName).append(" = ").append(number)
+                val isPackRequested = annotations.filterIsInstance<ProtoPacked>().singleOrNull() != null
 
-            val isPackRequested = annotations.filterIsInstance<ProtoPacked>().singleOrNull() != null
+                when {
+                    !isPackRequested ||
+                        !isList || // ignore as packed only meaningful on repeated types
+                        !fieldDescriptor.getElementDescriptor(0).isPackable // Ignore if the type is not allowed to be packed
+                    -> appendLine(';')
 
-            when {
-                !isPackRequested ||
-                !isList || // ignore as packed only meaningful on repeated types
-                !fieldDescriptor.getElementDescriptor(0).isPackable // Ignore if the type is not allowed to be packed
-                     -> appendLine(';')
-                else -> appendLine(" [packed=true];")
+                    else -> appendLine(" [packed=true];")
+                }
             }
         }
-        appendLine('}')
-
-        return nestedTypes
     }
 
-    private fun StringBuilder.generateNamedType(messageType: TypeDefinition, index: Int): List<TypeDefinition> {
-        val messageDescriptor = messageType.descriptor
-
-        val fieldDescriptor = messageDescriptor.getElementDescriptor(index)
+    private fun StringBuilder.generateNamedType(
+        fieldDescriptor: SerialDescriptor,
+        annotations: List<Annotation>,
+        isSealedPolymorphic: Boolean,
+        isOptional: Boolean,
+        inOneOfStruct: Boolean = false,
+        indent: Int = 1,
+    ): List<TypeDefinition> {
         var unwrappedFieldDescriptor = fieldDescriptor
         while (unwrappedFieldDescriptor.isInline) {
             unwrappedFieldDescriptor = unwrappedFieldDescriptor.getElementDescriptor(0)
@@ -223,18 +277,18 @@ public object ProtoBufSchemaGenerator {
 
         val nestedTypes: List<TypeDefinition>
         val typeName: String = when {
-            messageDescriptor.isSealedPolymorphic && index == 1 -> {
-                appendLine("  // decoded as message with one of these types:")
+            isSealedPolymorphic -> {
+                append(" ".repeat(indent * 2)).appendLine("// decoded as message with one of these types:")
                 nestedTypes = unwrappedFieldDescriptor.elementDescriptors.map { TypeDefinition(it) }.toList()
                 nestedTypes.forEachIndexed { _, childType ->
-                    append("  //   message ").append(childType.descriptor.messageOrEnumName).append(", serial name '")
+                    append(" ".repeat(indent * 2)).append("//   message ").append(childType.descriptor.messageOrEnumName).append(", serial name '")
                         .append(removeLineBreaks(childType.descriptor.serialName)).appendLine('\'')
                 }
                 unwrappedFieldDescriptor.scalarTypeName()
             }
             unwrappedFieldDescriptor.isProtobufScalar -> {
                 nestedTypes = emptyList()
-                unwrappedFieldDescriptor.scalarTypeName(messageDescriptor.getElementAnnotations(index))
+                unwrappedFieldDescriptor.scalarTypeName(annotations)
             }
             unwrappedFieldDescriptor.isOpenPolymorphic -> {
                 nestedTypes = listOf(SyntheticPolymorphicType)
@@ -247,12 +301,18 @@ public object ProtoBufSchemaGenerator {
             }
         }
 
-        if (messageDescriptor.isElementOptional(index)) {
-            appendLine("  // WARNING: a default value decoded when value is missing")
+        if (isOptional) {
+            append(" ".repeat(indent * 2)).appendLine("// WARNING: a default value decoded when value is missing")
         }
-        val optional = fieldDescriptor.isNullable || messageDescriptor.isElementOptional(index)
+        val optional = fieldDescriptor.isNullable || isOptional
 
-        append("  ").append(if (optional) "optional " else "required ").append(typeName)
+        append(" ".repeat(indent * 2)).append(
+            when {
+                inOneOfStruct -> ""
+                optional -> "optional "
+                else -> "required "
+            }
+        ).append(typeName)
 
         return nestedTypes
     }
@@ -396,6 +456,9 @@ public object ProtoBufSchemaGenerator {
     private val SerialDescriptor.messageOrEnumName: String
         get() = (serialName.substringAfterLast('.', serialName)).removeSuffix("?")
 
+    private fun SerialDescriptor.isChildOneOfMessage(index: Int): Boolean =
+        this.getElementDescriptor(index).isSealedPolymorphic && this.getElementAnnotations(index).any { it is ProtoOneOf }
+
     private fun SerialDescriptor.protobufTypeName(annotations: List<Annotation> = emptyList()): String {
         return if (isProtobufScalar) {
             scalarTypeName(annotations)
diff --git a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtoOneofInline.kt b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtoOneofInline.kt
new file mode 100644
index 000000000..4e303b571
--- /dev/null
+++ b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtoOneofInline.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization.protobuf
+
+import kotlinx.serialization.*
+import kotlin.jvm.*
+import kotlin.test.*
+
+class ProtoInline {
+
+    @Serializable
+    data class OneOfDataNullable(
+        @ProtoOneOf val i: ITypeWithInlineClass?,
+        @ProtoNumber(3) val name: String
+    )
+
+    @Serializable
+    sealed interface ITypeWithInlineClass
+
+    @Serializable
+    @JvmInline
+    value class StringInlineType(@ProtoNumber(12) val s: String) : ITypeWithInlineClass
+
+    @Test
+    fun testOneOfStringTypeNullable() {
+        val dataString = OneOfDataNullable(
+            StringInlineType("bar"),
+            "foo")
+        ProtoBuf.encodeToHexString(OneOfDataNullable.serializer(), dataString).also {
+            /**
+             * 12: {"bar"}
+             * 3: {"foo"}
+             */
+            assertEquals("62036261721a03666f6f", it)
+        }
+        ProtoBuf.decodeFromHexString<OneOfDataNullable>("62036261721a03666f6f").also {
+            assertEquals(dataString, it)
+        }
+        val dataStringNull = OneOfDataNullable(null, "foo")
+        ProtoBuf.encodeToHexString(OneOfDataNullable.serializer(), dataStringNull).also {
+            /**
+             * 3: {"foo"}
+             */
+            assertEquals("1a03666f6f", it)
+        }
+    }
+}
\ No newline at end of file
diff --git a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtobufOneOfTest.kt b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtobufOneOfTest.kt
new file mode 100644
index 000000000..63d7dd504
--- /dev/null
+++ b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/ProtobufOneOfTest.kt
@@ -0,0 +1,755 @@
+/*
+ * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization.protobuf
+
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+import kotlinx.serialization.modules.*
+import kotlinx.serialization.protobuf.internal.*
+import kotlin.jvm.*
+import kotlin.test.*
+
+class ProtobufOneOfTest {
+    @Serializable
+    data class OneOfData(
+        @ProtoOneOf val i: IType,
+        @ProtoNumber(3) val name: String
+    )
+
+    @Serializable
+    data class OneOfDataNullable(
+        @ProtoOneOf val i: IType?,
+        @ProtoNumber(3) val name: String
+    )
+
+    @Serializable
+    data class DataNoOneOf(
+        @ProtoNumber(5) val i: Int = 0,
+        @ProtoNumber(6) val s: String = "",
+        @ProtoNumber(3) val name: String,
+    )
+
+    @Serializable
+    sealed interface IType
+
+    @Serializable
+    data class IntType(@ProtoNumber(5) val i: Int = 0) : IType
+
+    @Serializable
+    @JvmInline
+    value class StringType(@ProtoNumber(6) val s: String) : IType
+
+    @Serializable
+    data class NestedIntType(@ProtoNumber(7) val intType: IntType) : IType
+
+    @Test
+    fun testOneOfIntType() {
+        val dataInt = OneOfData(IntType(42), "foo")
+        val intString = ProtoBuf.encodeToHexString(OneOfData.serializer(), dataInt)
+        /**
+         * 5:VARINT 42
+         * 3:LEN {"foo"}
+         */
+        assertEquals("282a1a03666f6f", intString)
+    }
+
+    @Test
+    fun testOneOfStringType() {
+        val dataString = OneOfData(StringType("bar"), "foo")
+        val stringString = ProtoBuf.encodeToHexString(OneOfData.serializer(), dataString)
+        /**
+         * 6:LEN {"bar"}
+         * 3:LEN {"foo"}
+         */
+        assertEquals("32036261721a03666f6f", stringString)
+    }
+
+    @Test
+    fun testOneOfDecodeStringType() {
+        /**
+         * 6:LEN {"bar"}
+         * 3:LEN {"foo"}
+         */
+        val dataString = ProtoBuf.decodeFromHexString<OneOfData>("32036261721a03666f6f")
+        assertEquals(OneOfData(StringType("bar"), "foo"), dataString)
+    }
+
+    @Test
+    fun testOneOfDecodeIntType() {
+        /**
+         * 5:VARINT 42
+         * 3:LEN {"foo"}
+         */
+        val dataInt = ProtoBuf.decodeFromHexString<OneOfData>("282a1a03666f6f")
+        assertEquals(OneOfData(IntType(42), "foo"), dataInt)
+    }
+
+    @Test
+    fun testOneOfIntTypeNullable() {
+        val dataInt = OneOfDataNullable(IntType(42), "foo")
+        ProtoBuf.encodeToHexString(OneOfDataNullable.serializer(), dataInt).also {
+            /**
+             * 5:VARINT 42
+             * 3:LEN {"foo"}
+             */
+            assertEquals("282a1a03666f6f", it)
+        }
+
+    }
+
+    @Test
+    fun testOneOfStringTypeNullable() {
+        val dataString = OneOfDataNullable(StringType("bar"), "foo")
+        ProtoBuf.encodeToHexString(OneOfDataNullable.serializer(), dataString).also {
+            /**
+             * 6:LEN {"bar"}
+             * 3:LEN {"foo"}
+             */
+            assertEquals("32036261721a03666f6f", it)
+        }
+        val dataStringNull = OneOfDataNullable(null, "foo")
+        ProtoBuf.encodeToHexString(OneOfDataNullable.serializer(), dataStringNull).also {
+            /**
+             * 3:LEN {"foo"}
+             */
+            assertEquals("1a03666f6f", it)
+        }
+    }
+
+    @Test
+    fun testOneOfDecodeNullable() {
+        /**
+         * 6:LEN {"bar"}
+         * 3:LEN {"foo"}
+         */
+        ProtoBuf.decodeFromHexString<OneOfDataNullable>("32036261721a03666f6f").let {
+            assertEquals(OneOfDataNullable(StringType("bar"), "foo"), it)
+        }
+        /**
+         * 5:VARINT 42
+         * 3:LEN {"foo"}
+         */
+        ProtoBuf.decodeFromHexString<OneOfDataNullable>("282a1a03666f6f").let {
+            assertEquals(OneOfDataNullable(IntType(42), "foo"), it)
+        }
+        /**
+         * 3:LEN {"foo"}
+         */
+        ProtoBuf.decodeFromHexString<OneOfDataNullable>("1a03666f6f").let {
+            assertEquals(OneOfDataNullable(null, "foo"), it)
+        }
+    }
+
+    @Test
+    fun testOneOfToFlatInt() {
+        val dataInt = OneOfData(IntType(42), "foo")
+        ProtoBuf.encodeToByteArray(dataInt).let {
+            ProtoBuf.decodeFromByteArray<DataNoOneOf>(it).let { data ->
+                assertEquals(
+                    DataNoOneOf(42, "", "foo"), data
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testOneOfToFlatString() {
+        val dataString = OneOfData(StringType("bar"), "foo")
+        ProtoBuf.encodeToByteArray(dataString).let {
+            ProtoBuf.decodeFromByteArray<DataNoOneOf>(it).let { data ->
+                assertEquals(
+                    DataNoOneOf(0, "bar", "foo"), data
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testFlatIntToOneOf() {
+        val dataInt = DataNoOneOf(42, "", "foo")
+        ProtoBuf.encodeToByteArray(dataInt).let {
+            ProtoBuf.decodeFromByteArray<OneOfData>(it).let { data ->
+                assertEquals(
+                    OneOfData(IntType(42), "foo"), data
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testFlatStringToOneOf() {
+        val dataString = DataNoOneOf(0, "bar", "foo")
+        ProtoBuf.encodeToByteArray(dataString).let {
+            ProtoBuf.decodeFromByteArray<OneOfData>(it).let { data ->
+                assertEquals(
+                    OneOfData(StringType("bar"), "foo"), data
+                )
+            }
+        }
+    }
+
+    @Test
+    fun testEncodeNestedStruct() {
+        val data = OneOfData(NestedIntType(IntType(32)), "foo")
+        ProtoBuf.encodeToHexString(OneOfData.serializer(), data).also {
+            /**
+             * 7:LEN {5:VARINT 32}
+             * 3:LEN {"foo"}
+             */
+            assertEquals("3a0228201a03666f6f", it)
+        }
+    }
+
+    @Test
+    fun testDecodeNestedStruct() {
+        val data = OneOfData(NestedIntType(IntType(32)), "foo")
+        /**
+         * 7:LEN {5:VARINT 32}
+         * 3:LEN {"foo"}
+         */
+        ProtoBuf.decodeFromHexString<OneOfData>("3a0228201a03666f6f").also {
+            assertEquals(data, it)
+        }
+    }
+
+    @Serializable
+    data class FailOuter(@ProtoOneOf val i: IFailSuper, @ProtoNumber(3) val name: String)
+
+    @Serializable
+    data class FailOuterHelper(
+        @ProtoNumber(5) val i: Int,
+        @ProtoNumber(6) val j: Int,
+        @ProtoNumber(3) val name: String
+    )
+
+    @Serializable
+    sealed interface IFailSuper
+
+    @Serializable
+    data class FailType(@ProtoNumber(5) val i: Int, @ProtoNumber(6) val j: Int) : IFailSuper
+
+    @Test
+    fun testOneOfElementCheck() {
+        val data = FailOuter(FailType(1, 2), "foo")
+        assertFailsWithMessage<IllegalArgumentException>(
+            message = "Implementation of oneOf type" +
+                " kotlinx.serialization.protobuf.ProtobufOneOfTest.FailType" +
+                " should contain only 1 element, but get 2"
+        ) {
+            ProtoBuf.encodeToHexString(data)
+        }
+
+        /**
+         * 5:VARINT 42
+         * 3:LEN {"foo"}
+         */
+        assertFailsWithMessage<IllegalArgumentException>(
+            message = "Implementation of oneOf type" +
+                " kotlinx.serialization.protobuf.ProtobufOneOfTest.FailType" +
+                " should contain only 1 element, but get 2"
+        ) {
+            ProtoBuf.decodeFromHexString<FailOuter>("282a1a03666f6f")
+        }
+
+        /**
+         * 5:VARINT 1
+         * 6:VARINT 2
+         * 3:LEN {"foo"}
+         */
+        assertFailsWithMessage<IllegalArgumentException>(
+            message = "Implementation of oneOf type" +
+                " kotlinx.serialization.protobuf.ProtobufOneOfTest.FailType" +
+                " should contain only 1 element, but get 2"
+        ) {
+            ProtoBuf.decodeFromHexString<FailOuter>(
+                ProtoBuf.encodeToHexString(
+                    FailOuterHelper(
+                        i = 1,
+                        j = 2,
+                        name = "foo"
+                    )
+                )
+            )
+        }
+
+    }
+
+    @Serializable
+    data class NestedOneOfType(@ProtoNumber(9) val i: InnerNested) : IType
+
+    @Serializable
+    data class InnerNested(@ProtoOneOf val i: InnerOneOf)
+
+    @Serializable
+    sealed interface InnerOneOf
+
+    @Serializable
+    data class InnerInt(@ProtoNumber(1) val i: Int) : InnerOneOf
+
+    @Serializable
+    data class InnerString(@ProtoNumber(2) val s: String) : InnerOneOf
+
+    @Test
+    fun testEncodeNestedOneOf() {
+        val data = OneOfData(NestedOneOfType(i = InnerNested(InnerInt(32))), "foo")
+        ProtoBuf.encodeToHexString(OneOfData.serializer(), data).also {
+            /**
+             * 9:LEN {1:VARINT 32}
+             * 3:LEN {"foo"}
+             */
+            assertEquals("4a0208201a03666f6f", it)
+        }
+    }
+
+    @Test
+    fun testDecodeNestedOneOf() {
+        val data = OneOfData(NestedOneOfType(i = InnerNested(InnerInt(32))), "foo")
+        /**
+         * 9:LEN {1:VARINT 32}
+         * 3:LEN {"foo"}
+         */
+        ProtoBuf.decodeFromHexString<OneOfData>("4a0208201a03666f6f").also {
+            /**
+             * 9: {1: 32}
+             * 3: {"foo"}
+             */
+            assertEquals(data, it)
+        }
+    }
+
+    @Serializable
+    data class DoubleOneOfElement(
+        @ProtoOneOf val one: IType,
+        @ProtoNumber(3) val name: String,
+        @ProtoOneOf val two: OtherType
+    )
+
+    interface OtherType
+
+    @Serializable
+    data class OtherIntType(@ProtoNumber(11) val i: Int) : OtherType
+
+    @Serializable
+    data class OtherStringType(@ProtoNumber(12) val s: String) : OtherType
+
+    @Test
+    fun testEncodeDoubleOneOf() {
+        val module = SerializersModule {
+            polymorphic(OtherType::class) {
+                subclass(OtherStringType::class)
+            }
+        }
+        val buf = ProtoBuf {
+            serializersModule = module
+        }
+        val data = DoubleOneOfElement(
+            IntType(32),
+            "foo",
+            OtherStringType("bar")
+        )
+        buf.encodeToHexString(DoubleOneOfElement.serializer(), data).also {
+            /**
+             * 5:VARINT 32
+             * 3:LEN {"foo"}
+             * 12:LEN {"bar"}
+             */
+            assertEquals("28201a03666f6f6203626172", it)
+        }
+
+        assertFailsWithMessage<SerializationException>(
+            message = "Serializer for subclass 'OtherIntType' is not found in the polymorphic scope of 'OtherType'."
+        ) {
+            buf.encodeToHexString(
+                DoubleOneOfElement.serializer(), DoubleOneOfElement(
+                    IntType(32),
+                    "foo",
+                    OtherIntType(32)
+                )
+            )
+        }
+    }
+
+    @Test
+    fun testDecodeDoubleOneOf() {
+        val module = SerializersModule {
+            polymorphic(OtherType::class) {
+                subclass(OtherStringType::class)
+            }
+        }
+        val buf = ProtoBuf {
+            serializersModule = module
+        }
+        val data = DoubleOneOfElement(
+            IntType(32),
+            "foo",
+            OtherStringType("bar")
+        )
+        /**
+         * 5:VARINT 32
+         * 3:LEN {"foo"}
+         * 12:LEN {"bar"}
+         */
+        buf.decodeFromHexString<DoubleOneOfElement>("28201a03666f6f6203626172").also {
+            assertEquals(data, it)
+        }
+    }
+
+    @Test
+    fun testCustomerModule() {
+        val module = SerializersModule {
+            polymorphic(IType::class) {
+                subclass(IntType::class, IntType.serializer())
+                subclass(StringType::class, StringType.serializer())
+            }
+        }
+
+        val buf = ProtoBuf { serializersModule = module }
+
+        val dataInt = OneOfData(IntType(42), "foo")
+        val intString = buf.encodeToHexString(OneOfData.serializer(), dataInt)
+        /**
+         * 5:VARINT 42
+         * 3:LEN {"foo"}
+         */
+        assertEquals("282a1a03666f6f", intString)
+
+        val dataString = OneOfData(StringType("bar"), "foo")
+        val stringString = buf.encodeToHexString(OneOfData.serializer(), dataString)
+        /**
+         * 6:LEN {"bar"}
+         * 3:LEN {"foo"}
+         */
+        assertEquals("32036261721a03666f6f", stringString)
+        val stringData = buf.decodeFromHexString<OneOfData>(stringString)
+        assertEquals(stringData, dataString)
+        val intData = buf.decodeFromHexString<OneOfData>(intString)
+        assertEquals(intData, dataInt)
+    }
+
+    @Serializable
+    data class FailWithClass(@ProtoOneOf val i: IFailType, @ProtoNumber(3) val name: String)
+
+    @Serializable
+    sealed interface IFailType
+
+    @Serializable
+    data class FailIntType(val i: Int) : IFailType
+
+    @Test
+    fun testFailWithClassEncoding() {
+        val data = FailWithClass(FailIntType(42), "foo")
+        assertFailsWithMessage<IllegalArgumentException>(
+            "Implementation of oneOf type kotlinx.serialization.protobuf.ProtobufOneOfTest.FailIntType should have @ProtoNumber annotation"
+        ) { ProtoBuf.encodeToHexString(FailWithClass.serializer(), data) }
+    }
+
+    @Test
+    fun testFailWithClassDecoding() {
+        assertFailsWithMessage<IllegalArgumentException>(
+            "kotlinx.serialization.protobuf.ProtobufOneOfTest.FailIntType implementing oneOf type kotlinx.serialization.protobuf.ProtobufOneOfTest.IFailType should have @ProtoNumber annotation in its single property."
+        ) {
+            ProtoBuf.decodeFromHexString<FailWithClass>(
+                /**
+                 * 5:VARINT 42
+                 * 3:LEN {"foo"}
+                 */
+                "282a1a03666f6f"
+            )
+        }
+    }
+
+    @Serializable
+    data class CustomOuter(@ProtoOneOf val inner: CustomInner)
+
+    @Serializable
+    abstract class CustomInner
+
+    data class CustomInnerInt(val i: Int) : CustomInner()
+
+    object CustomerInnerIntSerializer : KSerializer<CustomInnerInt> {
+        override val descriptor: SerialDescriptor
+            get() = buildClassSerialDescriptor("CustomInnerInt") {
+                element<Int>(
+                    "i",
+                    annotations = listOf(ProtoNumber(1)),
+                )
+            }
+
+        override fun deserialize(decoder: Decoder): CustomInnerInt {
+            return decoder.decodeStructure(descriptor) {
+                var value = 0
+                while (true) {
+                    when (val index = decodeElementIndex(descriptor)) {
+                        0 -> value = decodeIntElement(descriptor, index)
+                        CompositeDecoder.DECODE_DONE -> break
+                    }
+                }
+                CustomInnerInt(value)
+            }
+        }
+
+        override fun serialize(encoder: Encoder, value: CustomInnerInt) = encoder.encodeStructure(descriptor) {
+            encodeIntElement(descriptor, 0, value.i)
+        }
+
+    }
+
+    @Test
+    fun testCustom() {
+        val module = SerializersModule {
+            polymorphic(CustomInner::class) {
+                subclass(CustomInnerInt::class, CustomerInnerIntSerializer)
+            }
+        }
+        val data = CustomOuter(CustomInnerInt(42))
+        val buf = ProtoBuf { serializersModule = module }
+        /**
+         * 1:VARINT 42
+         */
+        assertEquals("082a", buf.encodeToHexString(CustomOuter.serializer(), data))
+    }
+
+    @Serializable
+    data class CustomAnyData(@ProtoOneOf @Polymorphic val inner: Any)
+
+    @Test
+    fun testCustomAny() {
+        val module = SerializersModule {
+            polymorphic(Any::class) {
+                subclass(CustomInnerInt::class, CustomerInnerIntSerializer)
+            }
+        }
+        val data = CustomAnyData(CustomInnerInt(42))
+        val buf = ProtoBuf { serializersModule = module }
+        /**
+         * 1:VARINT 42
+         */
+        assertEquals(data, buf.decodeFromHexString<CustomAnyData>("082a"))
+    }
+
+    @Serializable
+    data class DuplicatingIdData(
+        @ProtoOneOf val bad: IDuplicatingIdType,
+        @ProtoNumber(3) val d: Int,
+    )
+
+    @Serializable
+    sealed interface IDuplicatingIdType
+
+    @Serializable
+    data class DuplicatingIdStringType(@ProtoNumber(3) val s: String) : IDuplicatingIdType
+
+    @Test
+    fun testDuplicatedIdClass() {
+        val duplicated = DuplicatingIdData(DuplicatingIdStringType("foo"), 42)
+        // Fine to encode duplicated proto number properties in wire data
+        ProtoBuf.encodeToHexString(duplicated).also {
+            /**
+             * 3:LEN {"foo"}
+             * 3:VARINT 42
+             */
+            assertEquals("1a03666f6f182a", it)
+        }
+
+        // Without checking duplication of proto numbers,
+        // ProtoBuf just throw exception about wrong wire type
+        assertFailsWithMessage<IllegalArgumentException>(
+//            "Duplicated proto number 3 in kotlinx.serialization.protobuf.ProtobufOneOfTest.DuplicatingIdData for elements: d, bad."
+            "Expected wire type 0, but found 2"
+        ) {
+            /**
+             * 3:LEN {"foo"}
+             * 3:VARINT 42
+             */
+            ProtoBuf.decodeFromHexString<DuplicatingIdData>("1a03666f6f182a")
+        }
+    }
+
+    @Serializable
+    data class TypedIntOuter(
+        @ProtoOneOf val i: ITypedInt,
+    )
+
+    @Serializable
+    sealed interface ITypedInt
+
+    @Serializable
+    data class Fixed32Int(
+        @ProtoNumber(2)
+        @ProtoType(ProtoIntegerType.FIXED)
+        val value: Int
+    ) : ITypedInt
+
+    @Serializable
+    @JvmInline
+    value class Fixed32Long(
+        @ProtoNumber(3)
+        @ProtoType(ProtoIntegerType.FIXED)
+        val value: Long
+    ) : ITypedInt
+
+    @Serializable
+    @JvmInline
+    value class SignedInt(
+        @ProtoNumber(4)
+        @ProtoType(ProtoIntegerType.SIGNED)
+        val value: Int
+    ) : ITypedInt
+
+    @Serializable
+    data class SignedLong(
+        @ProtoNumber(5)
+        @ProtoType(ProtoIntegerType.SIGNED)
+        val value: Long
+    ) : ITypedInt
+
+    @Serializable
+    data class DefaultInt(
+        @ProtoNumber(6)
+        @ProtoType(ProtoIntegerType.DEFAULT)
+        val value: Int
+    ) : ITypedInt
+
+    @Serializable
+    data class DefaultLong(
+        @ProtoNumber(7)
+        @ProtoType(ProtoIntegerType.DEFAULT)
+        val value: Long
+    ) : ITypedInt
+
+    @Test
+    fun testTypedInt() {
+        val fixed = TypedIntOuter(Fixed32Int(32))
+        ProtoBuf.encodeToHexString(fixed).also {
+            /**
+             * 2:I32 32i32
+             */
+            assertEquals("1520000000", it)
+        }
+        /**
+         * 2:I32 32i32
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("1520000000").also {
+            assertEquals(fixed, it)
+        }
+        val fixedLong = TypedIntOuter(Fixed32Long(30576774159))
+        ProtoBuf.encodeToHexString(fixedLong).also {
+            /**
+             * 3:VARINT 30576774159
+             */
+            assertEquals("188f9892f471", it)
+        }
+        /**
+         * 3:VARINT 30576774159
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("188f9892f471").also {
+            assertEquals(fixedLong, it)
+        }
+        val signed = TypedIntOuter(SignedInt(32))
+        ProtoBuf.encodeToHexString(signed).also {
+            /**
+             * 4:VARINT 32
+             */
+            assertEquals("2020", it)
+        }
+        /**
+         * 4:VARINT 32
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("2020").also {
+            assertEquals(signed, it)
+        }
+        val signedLong = TypedIntOuter(SignedLong(30576774159))
+        ProtoBuf.encodeToHexString(signedLong).also {
+            /**
+             * 5:VARINT 61153548318
+             */
+            assertEquals("289eb0a4e8e301", it)
+        }
+        /**
+         * 5:VARINT 61153548318
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("289eb0a4e8e301").also {
+            assertEquals(signedLong, it)
+        }
+        val default = TypedIntOuter(DefaultInt(32))
+        ProtoBuf.encodeToHexString(default).also {
+            /**
+             * 6:VARINT 32
+             */
+            assertEquals("3020", it)
+        }
+        /**
+         * 6:VARINT 32
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("3020").also {
+            assertEquals(default, it)
+        }
+        val defaultLong = TypedIntOuter(DefaultLong(30576774159))
+        ProtoBuf.encodeToHexString(defaultLong).also {
+            /**
+             * 7:VARINT 30576774159
+             */
+            assertEquals("388f9892f471", it)
+        }
+        /**
+         * 7:VARINT 30576774159
+         */
+        ProtoBuf.decodeFromHexString<TypedIntOuter>("388f9892f471").also {
+            assertEquals(defaultLong, it)
+        }
+    }
+
+    // @ProtoNumber(777) here should be ignored
+    @Serializable
+    data class Dummy(@ProtoNumber(777) @ProtoOneOf val i: DummyInterface)
+
+    @Serializable
+    sealed interface DummyInterface
+    @Serializable
+    data class DummyInt(@ProtoNumber(1) val i: Int) : DummyInterface
+
+    @Test
+    fun testDummyAnnotation() {
+        val data = Dummy(DummyInt(42))
+        ProtoBuf.encodeToHexString(data).also {
+            /**
+             * 1:VARINT 42
+             */
+            assertEquals("082a", it)
+        }
+        /**
+         * 1:VARINT 42
+         */
+        ProtoBuf.decodeFromHexString<Dummy>("082a").also {
+            assertEquals(data, it)
+        }
+    }
+
+    @Serializable
+    data class Outer(@ProtoOneOf val inner: Inner)
+
+    @Serializable
+    data class Inner(@ProtoNumber(1) val i: Int) // not sealed or abstract
+
+    @Test
+    fun testNonePolymorphicClass() {
+        val data = Outer(Inner(42))
+        assertFailsWithMessage<IllegalArgumentException>(
+            "The serializer of one of type kotlinx.serialization.protobuf.ProtobufOneOfTest.Inner should be using generic polymorphic serializer, but got CLASS"
+        ) {
+            // Fails in [kotlinx.serialization.protobuf.internal.OneOfPolymorphicEncoder.init]
+            ProtoBuf.encodeToHexString(data)
+        }
+
+        assertFailsWithMessage<IllegalArgumentException>(
+            "Class kotlinx.serialization.protobuf.ProtobufOneOfTest.Inner should be abstract or sealed or interface to be used as @ProtoOneOf property."
+        ) {
+            // Fails in [kotlinx.serialization.protobuf.internal.HelpersKt.getAllOneOfSerializerOfField]
+            ProtoBuf.decodeFromHexString<Outer>("082a")
+        }
+    }
+}
\ No newline at end of file
diff --git a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/TestFunctions.kt b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/TestFunctions.kt
index 7302c9953..c321c4786 100644
--- a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/TestFunctions.kt
+++ b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/TestFunctions.kt
@@ -18,3 +18,15 @@ inline fun <reified T> testConversion(data: T, expectedHexString: String) {
     assertEquals(expectedHexString, string)
     assertEquals(data, ProtoBuf.decodeFromHexString(string))
 }
+
+inline fun <reified T : Throwable> assertFailsWithMessage(
+    message: String,
+    assertionMessage: String? = null,
+    block: () -> Unit
+) {
+    val exception = assertFailsWith(T::class, assertionMessage, block)
+    assertTrue(
+        exception.message!!.contains(message),
+        "expected:<$message> but was:<${exception.message}>"
+    )
+}
\ No newline at end of file
diff --git a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/schema/SchemaValidationsTest.kt b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/schema/SchemaValidationsTest.kt
index 033025029..ffe9d9434 100644
--- a/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/schema/SchemaValidationsTest.kt
+++ b/formats/protobuf/commonTest/src/kotlinx/serialization/protobuf/schema/SchemaValidationsTest.kt
@@ -2,8 +2,8 @@ package kotlinx.serialization.protobuf.schema
 
 import kotlinx.serialization.*
 import kotlinx.serialization.protobuf.*
-import kotlin.test.Test
-import kotlin.test.assertFailsWith
+import kotlin.jvm.*
+import kotlin.test.*
 
 class SchemaValidationsTest {
     @Serializable
@@ -138,4 +138,44 @@ class SchemaValidationsTest {
         assertFailsWith(IllegalArgumentException::class) { ProtoBufSchemaGenerator.generateSchemaText(listOf(FieldNumberDuplicates.serializer().descriptor)) }
         assertFailsWith(IllegalArgumentException::class) { ProtoBufSchemaGenerator.generateSchemaText(listOf(FieldNumberImplicitlyDuplicates.serializer().descriptor)) }
     }
+
+    @Serializable
+    data class OneOfData(
+        @ProtoNumber(1) val name: String,
+        @ProtoOneOf val i: IType
+    )
+
+    @Serializable
+    sealed interface IType
+
+    @Serializable
+    data class IntType(@ProtoNumber(2) val intValue: Int): IType
+
+    @Serializable
+    @JvmInline
+    value class StringType(@ProtoNumber(3) val strValue: String): IType
+
+    @Serializable
+    data class WrapType(@ProtoNumber(4) val content: InnerType): IType
+
+    @Serializable
+    data class InnerType(val innerContent: String)
+
+    @Test
+    fun testOneOfGenerate() {
+        val descriptors = listOf(OneOfData.serializer().descriptor)
+        ProtoBufSchemaGenerator.generateSchemaText(descriptors).also {
+            println(it)
+            assertContains(it, "oneof i")
+            assertContains(it, "message InnerType")
+            // oneof fields need no required keyword
+            assertFalse(it.contains("required int32"))
+        }
+
+        assertFailsWithMessage<IllegalArgumentException>(
+            message = "Implementation of oneOf type kotlinx.serialization.protobuf.ProtobufOneOfTest.FailType should contain only 1 element, but get 2"
+        ) {
+            ProtoBufSchemaGenerator.generateSchemaText(ProtobufOneOfTest.FailOuter.serializer().descriptor)
+        }
+    }
 }
diff --git a/guide/example/example-formats-08.kt b/guide/example/example-formats-08.kt
index 61d4aeb81..1316aa0d3 100644
--- a/guide/example/example-formats-08.kt
+++ b/guide/example/example-formats-08.kt
@@ -3,16 +3,30 @@ package example.exampleFormats08
 
 import kotlinx.serialization.*
 import kotlinx.serialization.protobuf.*
-import kotlinx.serialization.protobuf.schema.ProtoBufSchemaGenerator
 
+// The outer class
 @Serializable
-data class SampleData(
-    val amount: Long,
-    val description: String?,
-    val department: String = "QA"
+data class Data(
+    @ProtoNumber(1) val name: String,
+    @ProtoOneOf val phone: IPhoneType?,
 )
+
+// The oneof interface
+@Serializable sealed interface IPhoneType
+
+// Message holder for home_phone
+@Serializable @JvmInline value class HomePhone(@ProtoNumber(2) val number: String): IPhoneType
+
+// Message holder for work_phone. Can also be a value class, but we leave it as `data` to demonstrate that both variants can be used.
+@Serializable data class WorkPhone(@ProtoNumber(3) val number: String): IPhoneType
+
 fun main() {
-  val descriptors = listOf(SampleData.serializer().descriptor)
-  val schemas = ProtoBufSchemaGenerator.generateSchemaText(descriptors)
-  println(schemas)
+  val dataTom = Data("Tom", HomePhone("123"))
+  val stringTom = ProtoBuf.encodeToHexString(dataTom)
+  val dataJerry = Data("Jerry", WorkPhone("789"))
+  val stringJerry = ProtoBuf.encodeToHexString(dataJerry)
+  println(stringTom)
+  println(stringJerry)
+  println(ProtoBuf.decodeFromHexString<Data>(stringTom))
+  println(ProtoBuf.decodeFromHexString<Data>(stringJerry))
 }
diff --git a/guide/example/example-formats-09.kt b/guide/example/example-formats-09.kt
index 99ed45d2e..387061f08 100644
--- a/guide/example/example-formats-09.kt
+++ b/guide/example/example-formats-09.kt
@@ -2,17 +2,17 @@
 package example.exampleFormats09
 
 import kotlinx.serialization.*
-import kotlinx.serialization.properties.Properties // todo: remove when no longer needed
-import kotlinx.serialization.properties.*
+import kotlinx.serialization.protobuf.*
+import kotlinx.serialization.protobuf.schema.ProtoBufSchemaGenerator
 
 @Serializable
-class Project(val name: String, val owner: User)
-
-@Serializable
-class User(val name: String)
-
+data class SampleData(
+    val amount: Long,
+    val description: String?,
+    val department: String = "QA"
+)
 fun main() {
-    val data = Project("kotlinx.serialization",  User("kotlin"))
-    val map = Properties.encodeToMap(data)
-    map.forEach { (k, v) -> println("$k = $v") }
+  val descriptors = listOf(SampleData.serializer().descriptor)
+  val schemas = ProtoBufSchemaGenerator.generateSchemaText(descriptors)
+  println(schemas)
 }
diff --git a/guide/example/example-formats-10.kt b/guide/example/example-formats-10.kt
index 0fc318bd4..020f175da 100644
--- a/guide/example/example-formats-10.kt
+++ b/guide/example/example-formats-10.kt
@@ -2,35 +2,17 @@
 package example.exampleFormats10
 
 import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
-import kotlinx.serialization.modules.*
-
-class ListEncoder : AbstractEncoder() {
-    val list = mutableListOf<Any>()
-
-    override val serializersModule: SerializersModule = EmptySerializersModule()
-
-    override fun encodeValue(value: Any) {
-        list.add(value)
-    }
-}
-
-fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any> {
-    val encoder = ListEncoder()
-    encoder.encodeSerializableValue(serializer, value)
-    return encoder.list
-}
-
-inline fun <reified T> encodeToList(value: T) = encodeToList(serializer(), value)
+import kotlinx.serialization.properties.Properties // todo: remove when no longer needed
+import kotlinx.serialization.properties.*
 
 @Serializable
-data class Project(val name: String, val owner: User, val votes: Int)
+class Project(val name: String, val owner: User)
 
 @Serializable
-data class User(val name: String)
+class User(val name: String)
 
 fun main() {
-    val data = Project("kotlinx.serialization",  User("kotlin"), 9000)
-    println(encodeToList(data))
+    val data = Project("kotlinx.serialization",  User("kotlin"))
+    val map = Properties.encodeToMap(data)
+    map.forEach { (k, v) -> println("$k = $v") }
 }
diff --git a/guide/example/example-formats-11.kt b/guide/example/example-formats-11.kt
index 942febb10..9fa4180d8 100644
--- a/guide/example/example-formats-11.kt
+++ b/guide/example/example-formats-11.kt
@@ -24,29 +24,6 @@ fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any>
 
 inline fun <reified T> encodeToList(value: T) = encodeToList(serializer(), value)
 
-class ListDecoder(val list: ArrayDeque<Any>) : AbstractDecoder() {
-    private var elementIndex = 0
-
-    override val serializersModule: SerializersModule = EmptySerializersModule()
-
-    override fun decodeValue(): Any = list.removeFirst()
-    
-    override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
-        if (elementIndex == descriptor.elementsCount) return CompositeDecoder.DECODE_DONE
-        return elementIndex++
-    }
-
-    override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
-        ListDecoder(list)
-}
-
-fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>): T {
-    val decoder = ListDecoder(ArrayDeque(list))
-    return decoder.decodeSerializableValue(deserializer)
-}
-
-inline fun <reified T> decodeFromList(list: List<Any>): T = decodeFromList(list, serializer())
-
 @Serializable
 data class Project(val name: String, val owner: User, val votes: Int)
 
@@ -55,8 +32,5 @@ data class User(val name: String)
 
 fun main() {
     val data = Project("kotlinx.serialization",  User("kotlin"), 9000)
-    val list = encodeToList(data)
-    println(list)
-    val obj = decodeFromList<Project>(list)
-    println(obj)
+    println(encodeToList(data))
 }
diff --git a/guide/example/example-formats-12.kt b/guide/example/example-formats-12.kt
index 1e83b9bf5..803f331e6 100644
--- a/guide/example/example-formats-12.kt
+++ b/guide/example/example-formats-12.kt
@@ -37,10 +37,8 @@ class ListDecoder(val list: ArrayDeque<Any>) : AbstractDecoder() {
     }
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
-        ListDecoder(list) 
-
-    override fun decodeSequentially(): Boolean = true
-}        
+        ListDecoder(list)
+}
 
 fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>): T {
     val decoder = ListDecoder(ArrayDeque(list))
diff --git a/guide/example/example-formats-13.kt b/guide/example/example-formats-13.kt
index 62ecdc66d..568017765 100644
--- a/guide/example/example-formats-13.kt
+++ b/guide/example/example-formats-13.kt
@@ -13,12 +13,7 @@ class ListEncoder : AbstractEncoder() {
 
     override fun encodeValue(value: Any) {
         list.add(value)
-    }                               
-
-    override fun beginCollection(descriptor: SerialDescriptor, collectionSize: Int): CompositeEncoder {
-        encodeInt(collectionSize)
-        return this
-    }                                                
+    }
 }
 
 fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any> {
@@ -29,26 +24,23 @@ fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any>
 
 inline fun <reified T> encodeToList(value: T) = encodeToList(serializer(), value)
 
-class ListDecoder(val list: ArrayDeque<Any>, var elementsCount: Int = 0) : AbstractDecoder() {
+class ListDecoder(val list: ArrayDeque<Any>) : AbstractDecoder() {
     private var elementIndex = 0
 
     override val serializersModule: SerializersModule = EmptySerializersModule()
 
     override fun decodeValue(): Any = list.removeFirst()
-
+    
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
-        if (elementIndex == elementsCount) return CompositeDecoder.DECODE_DONE
+        if (elementIndex == descriptor.elementsCount) return CompositeDecoder.DECODE_DONE
         return elementIndex++
     }
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
-        ListDecoder(list, descriptor.elementsCount)
+        ListDecoder(list) 
 
     override fun decodeSequentially(): Boolean = true
-
-    override fun decodeCollectionSize(descriptor: SerialDescriptor): Int =
-        decodeInt().also { elementsCount = it }
-}
+}        
 
 fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>): T {
     val decoder = ListDecoder(ArrayDeque(list))
@@ -58,13 +50,13 @@ fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>
 inline fun <reified T> decodeFromList(list: List<Any>): T = decodeFromList(list, serializer())
 
 @Serializable
-data class Project(val name: String, val owners: List<User>, val votes: Int)
+data class Project(val name: String, val owner: User, val votes: Int)
 
 @Serializable
 data class User(val name: String)
 
 fun main() {
-    val data = Project("kotlinx.serialization",  listOf(User("kotlin"), User("jetbrains")), 9000)
+    val data = Project("kotlinx.serialization",  User("kotlin"), 9000)
     val list = encodeToList(data)
     println(list)
     val obj = decodeFromList<Project>(list)
diff --git a/guide/example/example-formats-14.kt b/guide/example/example-formats-14.kt
index cd823e8d9..3f88d51ca 100644
--- a/guide/example/example-formats-14.kt
+++ b/guide/example/example-formats-14.kt
@@ -19,9 +19,6 @@ class ListEncoder : AbstractEncoder() {
         encodeInt(collectionSize)
         return this
     }                                                
-
-    override fun encodeNull() = encodeValue("NULL")
-    override fun encodeNotNullMark() = encodeValue("!!")
 }
 
 fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any> {
@@ -34,7 +31,7 @@ inline fun <reified T> encodeToList(value: T) = encodeToList(serializer(), value
 
 class ListDecoder(val list: ArrayDeque<Any>, var elementsCount: Int = 0) : AbstractDecoder() {
     private var elementIndex = 0
-    
+
     override val serializersModule: SerializersModule = EmptySerializersModule()
 
     override fun decodeValue(): Any = list.removeFirst()
@@ -51,8 +48,6 @@ class ListDecoder(val list: ArrayDeque<Any>, var elementsCount: Int = 0) : Abstr
 
     override fun decodeCollectionSize(descriptor: SerialDescriptor): Int =
         decodeInt().also { elementsCount = it }
-
-    override fun decodeNotNullMark(): Boolean = decodeString() != "NULL"
 }
 
 fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>): T {
@@ -63,16 +58,15 @@ fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>
 inline fun <reified T> decodeFromList(list: List<Any>): T = decodeFromList(list, serializer())
 
 @Serializable
-data class Project(val name: String, val owner: User?, val votes: Int?)
+data class Project(val name: String, val owners: List<User>, val votes: Int)
 
 @Serializable
 data class User(val name: String)
 
 fun main() {
-    val data = Project("kotlinx.serialization",  User("kotlin") , null)
+    val data = Project("kotlinx.serialization",  listOf(User("kotlin"), User("jetbrains")), 9000)
     val list = encodeToList(data)
     println(list)
     val obj = decodeFromList<Project>(list)
     println(obj)
 }
-
diff --git a/guide/example/example-formats-15.kt b/guide/example/example-formats-15.kt
index 81928d49b..c48c18e4f 100644
--- a/guide/example/example-formats-15.kt
+++ b/guide/example/example-formats-15.kt
@@ -2,54 +2,42 @@
 package example.exampleFormats15
 
 import kotlinx.serialization.*
-import kotlinx.serialization.Serializable
 import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.*
 import kotlinx.serialization.modules.*
-import java.io.*
 
-class DataOutputEncoder(val output: DataOutput) : AbstractEncoder() {
+class ListEncoder : AbstractEncoder() {
+    val list = mutableListOf<Any>()
+
     override val serializersModule: SerializersModule = EmptySerializersModule()
-    override fun encodeBoolean(value: Boolean) = output.writeByte(if (value) 1 else 0)
-    override fun encodeByte(value: Byte) = output.writeByte(value.toInt())
-    override fun encodeShort(value: Short) = output.writeShort(value.toInt())
-    override fun encodeInt(value: Int) = output.writeInt(value)
-    override fun encodeLong(value: Long) = output.writeLong(value)
-    override fun encodeFloat(value: Float) = output.writeFloat(value)
-    override fun encodeDouble(value: Double) = output.writeDouble(value)
-    override fun encodeChar(value: Char) = output.writeChar(value.code)
-    override fun encodeString(value: String) = output.writeUTF(value)
-    override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) = output.writeInt(index)
+
+    override fun encodeValue(value: Any) {
+        list.add(value)
+    }                               
 
     override fun beginCollection(descriptor: SerialDescriptor, collectionSize: Int): CompositeEncoder {
         encodeInt(collectionSize)
         return this
-    }
+    }                                                
 
-    override fun encodeNull() = encodeBoolean(false)
-    override fun encodeNotNullMark() = encodeBoolean(true)
+    override fun encodeNull() = encodeValue("NULL")
+    override fun encodeNotNullMark() = encodeValue("!!")
 }
 
-fun <T> encodeTo(output: DataOutput, serializer: SerializationStrategy<T>, value: T) {
-    val encoder = DataOutputEncoder(output)
+fun <T> encodeToList(serializer: SerializationStrategy<T>, value: T): List<Any> {
+    val encoder = ListEncoder()
     encoder.encodeSerializableValue(serializer, value)
+    return encoder.list
 }
 
-inline fun <reified T> encodeTo(output: DataOutput, value: T) = encodeTo(output, serializer(), value)
+inline fun <reified T> encodeToList(value: T) = encodeToList(serializer(), value)
 
-class DataInputDecoder(val input: DataInput, var elementsCount: Int = 0) : AbstractDecoder() {
+class ListDecoder(val list: ArrayDeque<Any>, var elementsCount: Int = 0) : AbstractDecoder() {
     private var elementIndex = 0
+    
     override val serializersModule: SerializersModule = EmptySerializersModule()
-    override fun decodeBoolean(): Boolean = input.readByte().toInt() != 0
-    override fun decodeByte(): Byte = input.readByte()
-    override fun decodeShort(): Short = input.readShort()
-    override fun decodeInt(): Int = input.readInt()
-    override fun decodeLong(): Long = input.readLong()
-    override fun decodeFloat(): Float = input.readFloat()
-    override fun decodeDouble(): Double = input.readDouble()
-    override fun decodeChar(): Char = input.readChar()
-    override fun decodeString(): String = input.readUTF()
-    override fun decodeEnum(enumDescriptor: SerialDescriptor): Int = input.readInt()
+
+    override fun decodeValue(): Any = list.removeFirst()
 
     override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
         if (elementIndex == elementsCount) return CompositeDecoder.DECODE_DONE
@@ -57,38 +45,34 @@ class DataInputDecoder(val input: DataInput, var elementsCount: Int = 0) : Abstr
     }
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
-        DataInputDecoder(input, descriptor.elementsCount)
+        ListDecoder(list, descriptor.elementsCount)
 
     override fun decodeSequentially(): Boolean = true
 
     override fun decodeCollectionSize(descriptor: SerialDescriptor): Int =
         decodeInt().also { elementsCount = it }
 
-    override fun decodeNotNullMark(): Boolean = decodeBoolean()
+    override fun decodeNotNullMark(): Boolean = decodeString() != "NULL"
 }
 
-fun <T> decodeFrom(input: DataInput, deserializer: DeserializationStrategy<T>): T {
-    val decoder = DataInputDecoder(input)
+fun <T> decodeFromList(list: List<Any>, deserializer: DeserializationStrategy<T>): T {
+    val decoder = ListDecoder(ArrayDeque(list))
     return decoder.decodeSerializableValue(deserializer)
 }
 
-inline fun <reified T> decodeFrom(input: DataInput): T = decodeFrom(input, serializer())
+inline fun <reified T> decodeFromList(list: List<Any>): T = decodeFromList(list, serializer())
 
-fun ByteArray.toAsciiHexString() = joinToString("") {
-    if (it in 32..127) it.toInt().toChar().toString() else
-        "{${it.toUByte().toString(16).padStart(2, '0').uppercase()}}"
-}
+@Serializable
+data class Project(val name: String, val owner: User?, val votes: Int?)
 
 @Serializable
-data class Project(val name: String, val language: String)
+data class User(val name: String)
 
 fun main() {
-    val data = Project("kotlinx.serialization", "Kotlin")
-    val output = ByteArrayOutputStream()
-    encodeTo(DataOutputStream(output), data)
-    val bytes = output.toByteArray()
-    println(bytes.toAsciiHexString())
-    val input = ByteArrayInputStream(bytes)
-    val obj = decodeFrom<Project>(DataInputStream(input))
+    val data = Project("kotlinx.serialization",  User("kotlin") , null)
+    val list = encodeToList(data)
+    println(list)
+    val obj = decodeFromList<Project>(list)
     println(obj)
 }
+
diff --git a/guide/example/example-formats-16.kt b/guide/example/example-formats-16.kt
index 24604902d..5bf0e4451 100644
--- a/guide/example/example-formats-16.kt
+++ b/guide/example/example-formats-16.kt
@@ -4,11 +4,10 @@ package example.exampleFormats16
 import kotlinx.serialization.*
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.modules.*
 import kotlinx.serialization.encoding.*
+import kotlinx.serialization.modules.*
 import java.io.*
 
-private val byteArraySerializer = serializer<ByteArray>()
 class DataOutputEncoder(val output: DataOutput) : AbstractEncoder() {
     override val serializersModule: SerializersModule = EmptySerializersModule()
     override fun encodeBoolean(value: Boolean) = output.writeByte(if (value) 1 else 0)
@@ -29,27 +28,6 @@ class DataOutputEncoder(val output: DataOutput) : AbstractEncoder() {
 
     override fun encodeNull() = encodeBoolean(false)
     override fun encodeNotNullMark() = encodeBoolean(true)
-
-    override fun <T> encodeSerializableValue(serializer: SerializationStrategy<T>, value: T) {
-        if (serializer.descriptor == byteArraySerializer.descriptor)
-            encodeByteArray(value as ByteArray)
-        else
-            super.encodeSerializableValue(serializer, value)
-    }
-
-    private fun encodeByteArray(bytes: ByteArray) {
-        encodeCompactSize(bytes.size)
-        output.write(bytes)
-    }
-    
-    private fun encodeCompactSize(value: Int) {
-        if (value < 0xff) {
-            output.writeByte(value)
-        } else {
-            output.writeByte(0xff)
-            output.writeInt(value)
-        }
-    }            
 }
 
 fun <T> encodeTo(output: DataOutput, serializer: SerializationStrategy<T>, value: T) {
@@ -87,25 +65,6 @@ class DataInputDecoder(val input: DataInput, var elementsCount: Int = 0) : Abstr
         decodeInt().also { elementsCount = it }
 
     override fun decodeNotNullMark(): Boolean = decodeBoolean()
-
-    @Suppress("UNCHECKED_CAST")
-    override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>, previousValue: T?): T =
-        if (deserializer.descriptor == byteArraySerializer.descriptor)
-            decodeByteArray() as T
-        else
-            super.decodeSerializableValue(deserializer, previousValue)
-
-    private fun decodeByteArray(): ByteArray {
-        val bytes = ByteArray(decodeCompactSize())
-        input.readFully(bytes)
-        return bytes
-    }
-
-    private fun decodeCompactSize(): Int {
-        val byte = input.readByte().toInt() and 0xff
-        if (byte < 0xff) return byte
-        return input.readInt()
-    }
 }
 
 fun <T> decodeFrom(input: DataInput, deserializer: DeserializationStrategy<T>): T {
@@ -121,10 +80,10 @@ fun ByteArray.toAsciiHexString() = joinToString("") {
 }
 
 @Serializable
-data class Project(val name: String, val attachment: ByteArray)
+data class Project(val name: String, val language: String)
 
 fun main() {
-    val data = Project("kotlinx.serialization", byteArrayOf(0x0A, 0x0B, 0x0C, 0x0D))
+    val data = Project("kotlinx.serialization", "Kotlin")
     val output = ByteArrayOutputStream()
     encodeTo(DataOutputStream(output), data)
     val bytes = output.toByteArray()
diff --git a/guide/example/example-formats-17.kt b/guide/example/example-formats-17.kt
new file mode 100644
index 000000000..9a1c5a21d
--- /dev/null
+++ b/guide/example/example-formats-17.kt
@@ -0,0 +1,135 @@
+// This file was automatically generated from formats.md by Knit tool. Do not edit.
+package example.exampleFormats17
+
+import kotlinx.serialization.*
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.modules.*
+import kotlinx.serialization.encoding.*
+import java.io.*
+
+private val byteArraySerializer = serializer<ByteArray>()
+class DataOutputEncoder(val output: DataOutput) : AbstractEncoder() {
+    override val serializersModule: SerializersModule = EmptySerializersModule()
+    override fun encodeBoolean(value: Boolean) = output.writeByte(if (value) 1 else 0)
+    override fun encodeByte(value: Byte) = output.writeByte(value.toInt())
+    override fun encodeShort(value: Short) = output.writeShort(value.toInt())
+    override fun encodeInt(value: Int) = output.writeInt(value)
+    override fun encodeLong(value: Long) = output.writeLong(value)
+    override fun encodeFloat(value: Float) = output.writeFloat(value)
+    override fun encodeDouble(value: Double) = output.writeDouble(value)
+    override fun encodeChar(value: Char) = output.writeChar(value.code)
+    override fun encodeString(value: String) = output.writeUTF(value)
+    override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) = output.writeInt(index)
+
+    override fun beginCollection(descriptor: SerialDescriptor, collectionSize: Int): CompositeEncoder {
+        encodeInt(collectionSize)
+        return this
+    }
+
+    override fun encodeNull() = encodeBoolean(false)
+    override fun encodeNotNullMark() = encodeBoolean(true)
+
+    override fun <T> encodeSerializableValue(serializer: SerializationStrategy<T>, value: T) {
+        if (serializer.descriptor == byteArraySerializer.descriptor)
+            encodeByteArray(value as ByteArray)
+        else
+            super.encodeSerializableValue(serializer, value)
+    }
+
+    private fun encodeByteArray(bytes: ByteArray) {
+        encodeCompactSize(bytes.size)
+        output.write(bytes)
+    }
+    
+    private fun encodeCompactSize(value: Int) {
+        if (value < 0xff) {
+            output.writeByte(value)
+        } else {
+            output.writeByte(0xff)
+            output.writeInt(value)
+        }
+    }            
+}
+
+fun <T> encodeTo(output: DataOutput, serializer: SerializationStrategy<T>, value: T) {
+    val encoder = DataOutputEncoder(output)
+    encoder.encodeSerializableValue(serializer, value)
+}
+
+inline fun <reified T> encodeTo(output: DataOutput, value: T) = encodeTo(output, serializer(), value)
+
+class DataInputDecoder(val input: DataInput, var elementsCount: Int = 0) : AbstractDecoder() {
+    private var elementIndex = 0
+    override val serializersModule: SerializersModule = EmptySerializersModule()
+    override fun decodeBoolean(): Boolean = input.readByte().toInt() != 0
+    override fun decodeByte(): Byte = input.readByte()
+    override fun decodeShort(): Short = input.readShort()
+    override fun decodeInt(): Int = input.readInt()
+    override fun decodeLong(): Long = input.readLong()
+    override fun decodeFloat(): Float = input.readFloat()
+    override fun decodeDouble(): Double = input.readDouble()
+    override fun decodeChar(): Char = input.readChar()
+    override fun decodeString(): String = input.readUTF()
+    override fun decodeEnum(enumDescriptor: SerialDescriptor): Int = input.readInt()
+
+    override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
+        if (elementIndex == elementsCount) return CompositeDecoder.DECODE_DONE
+        return elementIndex++
+    }
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeDecoder =
+        DataInputDecoder(input, descriptor.elementsCount)
+
+    override fun decodeSequentially(): Boolean = true
+
+    override fun decodeCollectionSize(descriptor: SerialDescriptor): Int =
+        decodeInt().also { elementsCount = it }
+
+    override fun decodeNotNullMark(): Boolean = decodeBoolean()
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T> decodeSerializableValue(deserializer: DeserializationStrategy<T>, previousValue: T?): T =
+        if (deserializer.descriptor == byteArraySerializer.descriptor)
+            decodeByteArray() as T
+        else
+            super.decodeSerializableValue(deserializer, previousValue)
+
+    private fun decodeByteArray(): ByteArray {
+        val bytes = ByteArray(decodeCompactSize())
+        input.readFully(bytes)
+        return bytes
+    }
+
+    private fun decodeCompactSize(): Int {
+        val byte = input.readByte().toInt() and 0xff
+        if (byte < 0xff) return byte
+        return input.readInt()
+    }
+}
+
+fun <T> decodeFrom(input: DataInput, deserializer: DeserializationStrategy<T>): T {
+    val decoder = DataInputDecoder(input)
+    return decoder.decodeSerializableValue(deserializer)
+}
+
+inline fun <reified T> decodeFrom(input: DataInput): T = decodeFrom(input, serializer())
+
+fun ByteArray.toAsciiHexString() = joinToString("") {
+    if (it in 32..127) it.toInt().toChar().toString() else
+        "{${it.toUByte().toString(16).padStart(2, '0').uppercase()}}"
+}
+
+@Serializable
+data class Project(val name: String, val attachment: ByteArray)
+
+fun main() {
+    val data = Project("kotlinx.serialization", byteArrayOf(0x0A, 0x0B, 0x0C, 0x0D))
+    val output = ByteArrayOutputStream()
+    encodeTo(DataOutputStream(output), data)
+    val bytes = output.toByteArray()
+    println(bytes.toAsciiHexString())
+    val input = ByteArrayInputStream(bytes)
+    val obj = decodeFrom<Project>(DataInputStream(input))
+    println(obj)
+}
diff --git a/guide/test/FormatsTest.kt b/guide/test/FormatsTest.kt
index c20a9f2af..f305a59bf 100644
--- a/guide/test/FormatsTest.kt
+++ b/guide/test/FormatsTest.kt
@@ -62,10 +62,20 @@ class FormatsTest {
     @Test
     fun testExampleFormats08() {
         captureOutput("ExampleFormats08") { example.exampleFormats08.main() }.verifyOutputLines(
+            "0a03546f6d1203313233",
+            "0a054a657272791a03373839",
+            "Data(name=Tom, phone=HomePhone(number=123))",
+            "Data(name=Jerry, phone=WorkPhone(number=789))"
+        )
+    }
+
+    @Test
+    fun testExampleFormats09() {
+        captureOutput("ExampleFormats09") { example.exampleFormats09.main() }.verifyOutputLines(
             "syntax = \"proto2\";",
             "",
             "",
-            "// serial name 'example.exampleFormats08.SampleData'",
+            "// serial name 'example.exampleFormats09.SampleData'",
             "message SampleData {",
             "  required int64 amount = 1;",
             "  optional string description = 2;",
@@ -77,63 +87,63 @@ class FormatsTest {
     }
 
     @Test
-    fun testExampleFormats09() {
-        captureOutput("ExampleFormats09") { example.exampleFormats09.main() }.verifyOutputLines(
+    fun testExampleFormats10() {
+        captureOutput("ExampleFormats10") { example.exampleFormats10.main() }.verifyOutputLines(
             "name = kotlinx.serialization",
             "owner.name = kotlin"
         )
     }
 
     @Test
-    fun testExampleFormats10() {
-        captureOutput("ExampleFormats10") { example.exampleFormats10.main() }.verifyOutputLines(
+    fun testExampleFormats11() {
+        captureOutput("ExampleFormats11") { example.exampleFormats11.main() }.verifyOutputLines(
             "[kotlinx.serialization, kotlin, 9000]"
         )
     }
 
     @Test
-    fun testExampleFormats11() {
-        captureOutput("ExampleFormats11") { example.exampleFormats11.main() }.verifyOutputLines(
+    fun testExampleFormats12() {
+        captureOutput("ExampleFormats12") { example.exampleFormats12.main() }.verifyOutputLines(
             "[kotlinx.serialization, kotlin, 9000]",
             "Project(name=kotlinx.serialization, owner=User(name=kotlin), votes=9000)"
         )
     }
 
     @Test
-    fun testExampleFormats12() {
-        captureOutput("ExampleFormats12") { example.exampleFormats12.main() }.verifyOutputLines(
+    fun testExampleFormats13() {
+        captureOutput("ExampleFormats13") { example.exampleFormats13.main() }.verifyOutputLines(
             "[kotlinx.serialization, kotlin, 9000]",
             "Project(name=kotlinx.serialization, owner=User(name=kotlin), votes=9000)"
         )
     }
 
     @Test
-    fun testExampleFormats13() {
-        captureOutput("ExampleFormats13") { example.exampleFormats13.main() }.verifyOutputLines(
+    fun testExampleFormats14() {
+        captureOutput("ExampleFormats14") { example.exampleFormats14.main() }.verifyOutputLines(
             "[kotlinx.serialization, 2, kotlin, jetbrains, 9000]",
             "Project(name=kotlinx.serialization, owners=[User(name=kotlin), User(name=jetbrains)], votes=9000)"
         )
     }
 
     @Test
-    fun testExampleFormats14() {
-        captureOutput("ExampleFormats14") { example.exampleFormats14.main() }.verifyOutputLines(
+    fun testExampleFormats15() {
+        captureOutput("ExampleFormats15") { example.exampleFormats15.main() }.verifyOutputLines(
             "[kotlinx.serialization, !!, kotlin, NULL]",
             "Project(name=kotlinx.serialization, owner=User(name=kotlin), votes=null)"
         )
     }
 
     @Test
-    fun testExampleFormats15() {
-        captureOutput("ExampleFormats15") { example.exampleFormats15.main() }.verifyOutputLines(
+    fun testExampleFormats16() {
+        captureOutput("ExampleFormats16") { example.exampleFormats16.main() }.verifyOutputLines(
             "{00}{15}kotlinx.serialization{00}{06}Kotlin",
             "Project(name=kotlinx.serialization, language=Kotlin)"
         )
     }
 
     @Test
-    fun testExampleFormats16() {
-        captureOutput("ExampleFormats16") { example.exampleFormats16.main() }.verifyOutputLines(
+    fun testExampleFormats17() {
+        captureOutput("ExampleFormats17") { example.exampleFormats17.main() }.verifyOutputLines(
             "{00}{15}kotlinx.serialization{04}{0A}{0B}{0C}{0D}",
             "Project(name=kotlinx.serialization, attachment=[10, 11, 12, 13])"
         )