diff --git a/core/api/kotlinx-serialization-core.api b/core/api/kotlinx-serialization-core.api
index 2ecdf89a57..0b08acb367 100644
--- a/core/api/kotlinx-serialization-core.api
+++ b/core/api/kotlinx-serialization-core.api
@@ -1336,6 +1336,7 @@ public final class kotlinx/serialization/modules/PolymorphicModuleBuilder {
 	public final fun default (Lkotlin/jvm/functions/Function1;)V
 	public final fun defaultDeserializer (Lkotlin/jvm/functions/Function1;)V
 	public final fun subclass (Lkotlin/reflect/KClass;Lkotlinx/serialization/KSerializer;)V
+	public final fun subclassesOfSealed (Lkotlinx/serialization/KSerializer;)V
 }
 
 public abstract class kotlinx/serialization/modules/SerializersModule {
diff --git a/core/api/kotlinx-serialization-core.klib.api b/core/api/kotlinx-serialization-core.klib.api
index 537c74c2db..97bc3b2ad6 100644
--- a/core/api/kotlinx-serialization-core.klib.api
+++ b/core/api/kotlinx-serialization-core.klib.api
@@ -527,9 +527,11 @@ final class <#A: in kotlin/Any> kotlinx.serialization.modules/PolymorphicModuleB
     constructor <init>(kotlin.reflect/KClass<#A>, kotlinx.serialization/KSerializer<#A>? = ...) // kotlinx.serialization.modules/PolymorphicModuleBuilder.<init>|<init>(kotlin.reflect.KClass<1:0>;kotlinx.serialization.KSerializer<1:0>?){}[0]
 
     final fun <#A1: #A> subclass(kotlin.reflect/KClass<#A1>, kotlinx.serialization/KSerializer<#A1>) // kotlinx.serialization.modules/PolymorphicModuleBuilder.subclass|subclass(kotlin.reflect.KClass<0:0>;kotlinx.serialization.KSerializer<0:0>){0§<1:0>}[0]
+    final fun <#A1: #A> subclassesOfSealed(kotlinx.serialization/KSerializer<#A1>) // kotlinx.serialization.modules/PolymorphicModuleBuilder.subclassesOfSealed|subclassesOfSealed(kotlinx.serialization.KSerializer<0:0>){0§<1:0>}[0]
     final fun buildTo(kotlinx.serialization.modules/SerializersModuleBuilder) // kotlinx.serialization.modules/PolymorphicModuleBuilder.buildTo|buildTo(kotlinx.serialization.modules.SerializersModuleBuilder){}[0]
     final fun default(kotlin/Function1<kotlin/String?, kotlinx.serialization/DeserializationStrategy<#A>?>) // kotlinx.serialization.modules/PolymorphicModuleBuilder.default|default(kotlin.Function1<kotlin.String?,kotlinx.serialization.DeserializationStrategy<1:0>?>){}[0]
     final fun defaultDeserializer(kotlin/Function1<kotlin/String?, kotlinx.serialization/DeserializationStrategy<#A>?>) // kotlinx.serialization.modules/PolymorphicModuleBuilder.defaultDeserializer|defaultDeserializer(kotlin.Function1<kotlin.String?,kotlinx.serialization.DeserializationStrategy<1:0>?>){}[0]
+    final inline fun <#A1: reified #A> subclassesOfSealed() // kotlinx.serialization.modules/PolymorphicModuleBuilder.subclassesOfSealed|subclassesOfSealed(){0§<1:0>}[0]
 }
 
 final class <#A: kotlin/Any, #B: #A?> kotlinx.serialization.internal/ReferenceArraySerializer : kotlinx.serialization.internal/CollectionLikeSerializer<#B, kotlin/Array<#B>, kotlin.collections/ArrayList<#B>> { // kotlinx.serialization.internal/ReferenceArraySerializer|null[0]
@@ -1171,6 +1173,7 @@ final inline fun (kotlinx.serialization.encoding/Encoder).kotlinx.serialization.
 final inline fun (kotlinx.serialization.encoding/Encoder).kotlinx.serialization.encoding/encodeStructure(kotlinx.serialization.descriptors/SerialDescriptor, crossinline kotlin/Function1<kotlinx.serialization.encoding/CompositeEncoder, kotlin/Unit>) // kotlinx.serialization.encoding/encodeStructure|encodeStructure@kotlinx.serialization.encoding.Encoder(kotlinx.serialization.descriptors.SerialDescriptor;kotlin.Function1<kotlinx.serialization.encoding.CompositeEncoder,kotlin.Unit>){}[0]
 final inline fun <#A: kotlin/Any, #B: reified #A> (kotlinx.serialization.modules/PolymorphicModuleBuilder<#A>).kotlinx.serialization.modules/subclass(kotlin.reflect/KClass<#B>) // kotlinx.serialization.modules/subclass|subclass@kotlinx.serialization.modules.PolymorphicModuleBuilder<0:0>(kotlin.reflect.KClass<0:1>){0§<kotlin.Any>;1§<0:0>}[0]
 final inline fun <#A: kotlin/Any, #B: reified #A> (kotlinx.serialization.modules/PolymorphicModuleBuilder<#A>).kotlinx.serialization.modules/subclass(kotlinx.serialization/KSerializer<#B>) // kotlinx.serialization.modules/subclass|subclass@kotlinx.serialization.modules.PolymorphicModuleBuilder<0:0>(kotlinx.serialization.KSerializer<0:1>){0§<kotlin.Any>;1§<0:0>}[0]
+final inline fun <#A: kotlin/Any, #B: reified #A> (kotlinx.serialization.modules/PolymorphicModuleBuilder<#A>).kotlinx.serialization.modules/subclassesOfSealed() // kotlinx.serialization.modules/subclassesOfSealed|subclassesOfSealed@kotlinx.serialization.modules.PolymorphicModuleBuilder<0:0>(){0§<kotlin.Any>;1§<0:0>}[0]
 final inline fun <#A: kotlin/Any> (kotlinx.serialization.modules/SerializersModuleBuilder).kotlinx.serialization.modules/polymorphic(kotlin.reflect/KClass<#A>, kotlinx.serialization/KSerializer<#A>? = ..., kotlin/Function1<kotlinx.serialization.modules/PolymorphicModuleBuilder<#A>, kotlin/Unit> = ...) // kotlinx.serialization.modules/polymorphic|polymorphic@kotlinx.serialization.modules.SerializersModuleBuilder(kotlin.reflect.KClass<0:0>;kotlinx.serialization.KSerializer<0:0>?;kotlin.Function1<kotlinx.serialization.modules.PolymorphicModuleBuilder<0:0>,kotlin.Unit>){0§<kotlin.Any>}[0]
 final inline fun <#A: kotlin/Any?> (kotlinx.serialization.encoding/Decoder).kotlinx.serialization.encoding/decodeStructure(kotlinx.serialization.descriptors/SerialDescriptor, crossinline kotlin/Function1<kotlinx.serialization.encoding/CompositeDecoder, #A>): #A // kotlinx.serialization.encoding/decodeStructure|decodeStructure@kotlinx.serialization.encoding.Decoder(kotlinx.serialization.descriptors.SerialDescriptor;kotlin.Function1<kotlinx.serialization.encoding.CompositeDecoder,0:0>){0§<kotlin.Any?>}[0]
 final inline fun <#A: kotlin/Any?> (kotlinx.serialization.encoding/Encoder).kotlinx.serialization.encoding/encodeCollection(kotlinx.serialization.descriptors/SerialDescriptor, kotlin.collections/Collection<#A>, crossinline kotlin/Function3<kotlinx.serialization.encoding/CompositeEncoder, kotlin/Int, #A, kotlin/Unit>) // kotlinx.serialization.encoding/encodeCollection|encodeCollection@kotlinx.serialization.encoding.Encoder(kotlinx.serialization.descriptors.SerialDescriptor;kotlin.collections.Collection<0:0>;kotlin.Function3<kotlinx.serialization.encoding.CompositeEncoder,kotlin.Int,0:0,kotlin.Unit>){0§<kotlin.Any?>}[0]
diff --git a/core/commonMain/src/kotlinx/serialization/SealedSerializer.kt b/core/commonMain/src/kotlinx/serialization/SealedSerializer.kt
index 52b7c0544d..74c17f6488 100644
--- a/core/commonMain/src/kotlinx/serialization/SealedSerializer.kt
+++ b/core/commonMain/src/kotlinx/serialization/SealedSerializer.kt
@@ -115,7 +115,7 @@ public class SealedClassSerializer<T : Any>(
         }
     }
 
-    private val class2Serializer: Map<KClass<out T>, KSerializer<out T>>
+    internal val class2Serializer: Map<KClass<out T>, KSerializer<out T>>
     private val serialName2Serializer: Map<String, KSerializer<out T>>
 
     init {
diff --git a/core/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt b/core/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt
index 1b8d431e1a..77cfe58123 100644
--- a/core/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt
+++ b/core/commonMain/src/kotlinx/serialization/modules/PolymorphicModuleBuilder.kt
@@ -5,6 +5,7 @@
 package kotlinx.serialization.modules
 
 import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.internal.*
 import kotlin.reflect.*
 
@@ -23,6 +24,84 @@ public class PolymorphicModuleBuilder<in Base : Any> @PublishedApi internal cons
     private var defaultSerializerProvider: ((Base) -> SerializationStrategy<Base>?)? = null
     private var defaultDeserializerProvider: ((String?) -> DeserializationStrategy<Base>?)? = null
 
+
+    /**
+     * Registers the child serializers for the sealed type [T] in the resulting module under the [base class][Base].
+     * Please note that type `T` has to be sealed and have a standard serializer, if not a runtime error will be
+     * thrown at registration time. If one of [T]'s subclasses is a sealed serializable class on its own, its
+     * subclasses are registered recursively as well. If one of [T]'s subclasses is an open polymorphic class
+     * an [IllegalArgumentException] is thrown.
+     *
+     * This function is a convenience function for the version that receives a serializer.
+     *
+     * Example:
+     * ```
+     * interface Base
+     *
+     * @Serializable
+     * sealed interface Sub: Base
+     *
+     * @Serializable
+     * class Sub1: Sub
+     *
+     * serializersModule {
+     *   polymorphic(Base::class) {
+     *      subclassesOfSealed<Sub>()
+     *   }
+     * }
+     * ```
+     */
+    @ExperimentalSerializationApi
+    public inline fun <reified T : Base> subclassesOfSealed(): Unit =
+        subclassesOfSealed(serializer<T>())
+
+
+    /**
+     * Registers the child serializers for the sealed  type [T] in the resulting module under the [base class][Base].
+     * Please note that type `T` has to be sealed and have a standard serializer, if not a runtime error will be
+     * thrown at registration time. If one of [T]'s subclasses is a sealed serializable class on its own, its
+     * subclasses are registered recursively as well. If one of [T]'s subclasses is an open polymorphic class
+     * an [IllegalArgumentException] is thrown.
+     *
+     * Example:
+     * ```kotlin
+     * interface Base
+     *
+     * @Serializable
+     * sealed interface Sub: Base
+     *
+     * @Serializable
+     * class Sub1: Sub
+     *
+     * serializersModule {
+     *   polymorphic(Base::class) {
+     *      subclassesOfSealed(Sub.serializer())
+     *   }
+     * }
+     * ```
+     *
+     * Note that if Sub1 is itself open polymorphic this is an error.
+     * 
+     */
+    @ExperimentalSerializationApi
+    public fun <T: Base> subclassesOfSealed(serializer: KSerializer<T>) {
+        // Note that the parameter type is `KSerializer` as `SealedClassSerializer` is an internal type
+        // not available to users
+        require(serializer is SealedClassSerializer) {
+            "subclassesOfSealed only supports automatic adding of subclasses of sealed types with standard serializers."
+        }
+        for ((subsubclass, subserializer) in serializer.class2Serializer.entries) {
+            // This error would be caught by the Json format in its validation, but this is format specific
+            require (subserializer.descriptor.kind != PolymorphicKind.OPEN) {
+                "It is not possible to register subclasses (${serializer.descriptor.serialName}) of sealed types when those subclasses " +
+                    "themselves are (open) polymorphic, as this would represent an incomplete hierarchy."
+            }
+            @Suppress("UNCHECKED_CAST")
+            // We don't know the type here, but it matches if correct in the sealed serializer.
+            subclass(subsubclass as KClass<T>, subserializer as KSerializer<T>)
+        }
+    }
+
     /**
      * Registers a [subclass] [serializer] in the resulting module under the [base class][Base].
      */
@@ -116,3 +195,10 @@ public inline fun <Base : Any, reified T : Base> PolymorphicModuleBuilder<Base>.
  */
 public inline fun <Base : Any, reified T : Base> PolymorphicModuleBuilder<Base>.subclass(clazz: KClass<T>): Unit =
     subclass(clazz, serializer())
+
+/**
+ * Registers the child serializers for the sealed class [T] in the resulting module under the [base class][Base].
+ */
+@ExperimentalSerializationApi
+public inline fun <Base : Any, reified T : Base> PolymorphicModuleBuilder<Base>.subclassesOfSealed(): Unit =
+    subclassesOfSealed(serializer<T>())
diff --git a/docs/polymorphism.md b/docs/polymorphism.md
index 9294b67c28..a896fad559 100644
--- a/docs/polymorphism.md
+++ b/docs/polymorphism.md
@@ -19,6 +19,7 @@ In this chapter we'll see how Kotlin Serialization deals with polymorphic class
 * [Open polymorphism](#open-polymorphism)
   * [Registered subclasses](#registered-subclasses)
   * [Serializing interfaces](#serializing-interfaces)
+  * [Registering sealed children as subclasses](#registering-sealed-children-as-subclasses)
   * [Property of an interface type](#property-of-an-interface-type)
   * [Static parent type lookup for polymorphism](#static-parent-type-lookup-for-polymorphism)
   * [Explicitly marking polymorphic class properties](#explicitly-marking-polymorphic-class-properties)
@@ -414,6 +415,68 @@ fun main() {
 
 > Note: On Kotlin/Native, you should use `format.encodeToString(PolymorphicSerializer(Project::class), data))` instead due to limited reflection capabilities.
 
+### Registering sealed children as subclasses
+A sealed parent interface or class can be used to directly register all its children using `subclassesOfSealed`.
+This will allow serializing the children using open polymorphism without the need to register each one individually. 
+
+If one of the type's subclasses is a sealed serializable class on its own, its subclasses are registered recursively
+as well. However, if one of the type's subclasses is an open polymorphic class, an [IllegalArgumentException] is thrown.
+In other words, all children/descendants must be either concrete or sealed.
+
+<!--- TEST -->
+
+<!--- INCLUDE
+import kotlinx.serialization.modules.*
+-->
+
+```kotlin
+interface Base
+
+@Serializable
+sealed interface Sub: Base
+
+@Serializable
+class Sub1(val data: String): Sub
+
+val module1 = SerializersModule {
+  polymorphic(Base::class) {
+     subclassesOfSealed(Sub.serializer())
+  }
+}
+
+val format1 = Json { serializersModule = module1 }
+```
+
+Alternatively the convenience overload allows specifying the sealed type as type parameter.
+
+```kotlin
+val module2 = SerializersModule {
+  polymorphic(Base::class) {
+     subclassesOfSealed<Sub>()
+  }
+}
+
+val format2 = Json { serializersModule = module2 }
+```
+
+Now if we declare `data` with the type of `Base` we can simply call `format.encodeToString` as before.
+```kotlin
+
+fun main() {
+    val data: Base = Sub1("kotlin")
+    println(format1.encodeToString(data))
+    println(format2.encodeToString(data))
+}
+```
+
+```text
+{"type":"example.examplePoly11.Sub1","data":"kotlin"}
+{"type":"example.examplePoly11.Sub1","data":"kotlin"}
+```
+
+> You can get the full code [here](../guide/example/example-poly-11.kt).
+
+
 <!--- TEST LINES_START -->
 
 ### Property of an interface type
@@ -451,7 +514,7 @@ fun main() {
 }        
 ```
 
-> You can get the full code [here](../guide/example/example-poly-11.kt).
+> You can get the full code [here](../guide/example/example-poly-12.kt).
 
 As long as we've registered the actual subtype of the interface that is being serialized in
 the [SerializersModule] of our `format`, we get it working at runtime.
@@ -496,7 +559,7 @@ fun main() {
 }    
 ```
 
-> You can get the full code [here](../guide/example/example-poly-12.kt).
+> You can get the full code [here](../guide/example/example-poly-13.kt).
  
 We get the exception.
 
@@ -544,7 +607,7 @@ fun main() {
 }    
 ```
 
-> You can get the full code [here](../guide/example/example-poly-13.kt).
+> You can get the full code [here](../guide/example/example-poly-14.kt).
 
 However, `Any` is a class and it is not serializable:
 
@@ -586,7 +649,7 @@ fun main() {
 }    
 ```
 
-> You can get the full code [here](../guide/example/example-poly-14.kt).
+> You can get the full code [here](../guide/example/example-poly-15.kt).
 
 With the explicit serializer it works as before.
 
@@ -639,7 +702,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-poly-15.kt).
+> You can get the full code [here](../guide/example/example-poly-16.kt).
  
 <!--- TEST 
 {"project":{"type":"owned","name":"kotlinx.coroutines","owner":"kotlin"}}
@@ -692,7 +755,7 @@ fun main() {
 }        
 -->
 
-> You can get the full code [here](../guide/example/example-poly-16.kt).
+> You can get the full code [here](../guide/example/example-poly-17.kt).
 
 <!--- TEST 
 {"project":{"type":"owned","name":"kotlinx.coroutines","owner":"kotlin"},"any":{"type":"owned","name":"kotlinx.coroutines","owner":"kotlin"}}
@@ -783,7 +846,7 @@ fun main() {
 
 ```
 
-> You can get the full code [here](../guide/example/example-poly-17.kt).
+> You can get the full code [here](../guide/example/example-poly-18.kt).
 
 The JSON that is being produced is deeply polymorphic.
 
@@ -831,7 +894,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-poly-18.kt).
+> You can get the full code [here](../guide/example/example-poly-19.kt).
 
 We get the following exception.
 
@@ -894,7 +957,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-poly-19.kt).
+> You can get the full code [here](../guide/example/example-poly-20.kt).
 
 Notice, how `BasicProject` had also captured the specified type key in its `type` property. 
 
@@ -998,7 +1061,7 @@ fun main() {
 }
 ```
 
-> You can get the full code [here](../guide/example/example-poly-20.kt)
+> You can get the full code [here](../guide/example/example-poly-21.kt)
 
 ```text
 {"type":"Cat","catType":"Tabby"}
diff --git a/docs/serialization-guide.md b/docs/serialization-guide.md
index ce7aeef343..730177f09f 100644
--- a/docs/serialization-guide.md
+++ b/docs/serialization-guide.md
@@ -97,6 +97,7 @@ Once the project is set up, we can start serializing some classes.
 * <a name='open-polymorphism'></a>[Open polymorphism](polymorphism.md#open-polymorphism)
   * <a name='registered-subclasses'></a>[Registered subclasses](polymorphism.md#registered-subclasses)
   * <a name='serializing-interfaces'></a>[Serializing interfaces](polymorphism.md#serializing-interfaces)
+  * <a name='registering-sealed-children-as-subclasses'></a>[Registering sealed children as subclasses](polymorphism.md#registering-sealed-children-as-subclasses)
   * <a name='property-of-an-interface-type'></a>[Property of an interface type](polymorphism.md#property-of-an-interface-type)
   * <a name='static-parent-type-lookup-for-polymorphism'></a>[Static parent type lookup for polymorphism](polymorphism.md#static-parent-type-lookup-for-polymorphism)
   * <a name='explicitly-marking-polymorphic-class-properties'></a>[Explicitly marking polymorphic class properties](polymorphism.md#explicitly-marking-polymorphic-class-properties)
diff --git a/formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphicSealedChildTest.kt b/formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphicSealedChildTest.kt
new file mode 100644
index 0000000000..332f3a02c5
--- /dev/null
+++ b/formats/json-tests/commonTest/src/kotlinx/serialization/features/PolymorphicSealedChildTest.kt
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2017-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.serialization.features
+
+import kotlinx.serialization.*
+import kotlinx.serialization.json.*
+import kotlinx.serialization.modules.*
+import kotlinx.serialization.test.*
+import kotlin.test.*
+
+class PolymorphicSealedChildTest {
+
+    @Serializable
+    data class FooHolder(
+        val someMetadata: Int,
+        val payload: List<FooBase>
+    )
+
+    @Serializable
+    abstract class FooBase
+
+    @Serializable
+    @SerialName("Foo")
+    sealed class Foo: FooBase() {
+        @Serializable
+        @SerialName("Bar")
+        data class Bar(val bar: Int) : Foo()
+        @Serializable
+        @SerialName("Baz")
+        sealed class Baz : Foo()
+
+        @Serializable
+        @SerialName("BazC1")
+        data class SealedBazChild1(val baz: String): Baz()
+        @Serializable
+        @SerialName("BazC2")
+        data class SealedBazChild2(val baz: String): Baz()
+
+    }
+
+    @Serializable
+    sealed class FooOpen: FooBase() {
+        @Serializable
+        data class Bar(val bar: Int) : FooOpen()
+        @Serializable
+        abstract class Baz: FooOpen()
+        @Serializable
+        @SerialName("BazOC1")
+        data class BazChild1(val baz: String) : Baz()
+        @Serializable
+        @SerialName("BazOC2")
+        data class BazChild2(val baz: String) : Baz()
+    }
+
+    val sealedModule = SerializersModule {
+        polymorphic(FooBase::class) {
+            subclassesOfSealed<Foo>()
+        }
+    }
+
+    val json = Json { serializersModule = sealedModule }
+
+    /**
+     * Test that attempting to register a grandchild (any descendant of the sealed intermediary)
+     * fails with an exception
+     */
+    @Test
+    fun testOpenGrandchildIsInvalid() {
+
+        lateinit var openJson: Json
+        val e = assertFailsWith<IllegalArgumentException> {
+            openJson = Json {
+                serializersModule = SerializersModule {
+                    polymorphic(FooBase::class) {
+                        subclassesOfSealed<FooOpen>()
+                    }
+                }
+            }
+
+        }
+        assertContains(assertNotNull(e.message), "FooOpen", )
+        assertContains(assertNotNull(e.message), "incomplete hierarchy", )
+    }
+
+    /**
+     * This tests both a directly sealed child (Bar) and a (sealed) grandchild (SealedBazChild1)
+     * Nesting sealed hierarchies is valid (and flattened by the plugin).
+     */
+    @Test
+    fun testSaveSealedClassesList() {
+        assertStringFormAndRestored(
+            """{"someMetadata":42,"payload":[
+            |{"type":"Bar","bar":1},
+            |{"type":"BazC1","baz":"2"}]}""".trimMargin().replace("\n", ""),
+            FooHolder(42, listOf(Foo.Bar(1), Foo.SealedBazChild1("2"))),
+            FooHolder.serializer(),
+            json,
+        )
+    }
+
+    /**
+     * Test that a simple direct descendant of the serialized base type can be serialized.
+     */
+    @Test
+    fun testCanSerializeSealedClassPolymorphicallyOnTopLevel() {
+        assertStringFormAndRestored(
+            """{"type":"Bar","bar":1}""",
+            Foo.Bar(1),
+            PolymorphicSerializer(FooBase::class),
+            json
+        )
+    }
+}
diff --git a/guide/example/example-poly-11.kt b/guide/example/example-poly-11.kt
index 30c3c4d7ce..ba6c68d24e 100644
--- a/guide/example/example-poly-11.kt
+++ b/guide/example/example-poly-11.kt
@@ -6,26 +6,33 @@ import kotlinx.serialization.json.*
 
 import kotlinx.serialization.modules.*
 
-val module = SerializersModule {
-    polymorphic(Project::class) {
-        subclass(OwnedProject::class)
-    }
+interface Base
+
+@Serializable
+sealed interface Sub: Base
+
+@Serializable
+class Sub1(val data: String): Sub
+
+val module1 = SerializersModule {
+  polymorphic(Base::class) {
+     subclassesOfSealed(Sub.serializer())
+  }
 }
 
-val format = Json { serializersModule = module }
+val format1 = Json { serializersModule = module1 }
 
-interface Project {
-    val name: String
+val module2 = SerializersModule {
+  polymorphic(Base::class) {
+     subclassesOfSealed<Sub>()
+  }
 }
 
-@Serializable
-@SerialName("owned")
-class OwnedProject(override val name: String, val owner: String) : Project
+val format2 = Json { serializersModule = module2 }
 
-@Serializable
-class Data(val project: Project) // Project is an interface
 
 fun main() {
-    val data = Data(OwnedProject("kotlinx.coroutines", "kotlin"))
-    println(format.encodeToString(data))
-}        
+    val data: Base = Sub1("kotlin")
+    println(format1.encodeToString(data))
+    println(format2.encodeToString(data))
+}
diff --git a/guide/example/example-poly-12.kt b/guide/example/example-poly-12.kt
index 5006cb4d5f..71ac2210fc 100644
--- a/guide/example/example-poly-12.kt
+++ b/guide/example/example-poly-12.kt
@@ -14,16 +14,18 @@ val module = SerializersModule {
 
 val format = Json { serializersModule = module }
 
-@Serializable
-abstract class Project {
-    abstract val name: String
+interface Project {
+    val name: String
 }
-            
+
 @Serializable
 @SerialName("owned")
-class OwnedProject(override val name: String, val owner: String) : Project()
+class OwnedProject(override val name: String, val owner: String) : Project
+
+@Serializable
+class Data(val project: Project) // Project is an interface
 
 fun main() {
-    val data: Any = OwnedProject("kotlinx.coroutines", "kotlin")
+    val data = Data(OwnedProject("kotlinx.coroutines", "kotlin"))
     println(format.encodeToString(data))
-}    
+}        
diff --git a/guide/example/example-poly-13.kt b/guide/example/example-poly-13.kt
index e79de66f9a..65c0e8c3f0 100644
--- a/guide/example/example-poly-13.kt
+++ b/guide/example/example-poly-13.kt
@@ -7,10 +7,11 @@ import kotlinx.serialization.json.*
 import kotlinx.serialization.modules.*
 
 val module = SerializersModule {
-    polymorphic(Any::class) {
+    polymorphic(Project::class) {
         subclass(OwnedProject::class)
     }
 }
+
 val format = Json { serializersModule = module }
 
 @Serializable
diff --git a/guide/example/example-poly-14.kt b/guide/example/example-poly-14.kt
index eea74517f4..7086a24f55 100644
--- a/guide/example/example-poly-14.kt
+++ b/guide/example/example-poly-14.kt
@@ -11,7 +11,6 @@ val module = SerializersModule {
         subclass(OwnedProject::class)
     }
 }
-
 val format = Json { serializersModule = module }
 
 @Serializable
@@ -25,5 +24,5 @@ class OwnedProject(override val name: String, val owner: String) : Project()
 
 fun main() {
     val data: Any = OwnedProject("kotlinx.coroutines", "kotlin")
-    println(format.encodeToString(PolymorphicSerializer(Any::class), data))
+    println(format.encodeToString(data))
 }    
diff --git a/guide/example/example-poly-15.kt b/guide/example/example-poly-15.kt
index e191b8f6c6..0b0f9a84b4 100644
--- a/guide/example/example-poly-15.kt
+++ b/guide/example/example-poly-15.kt
@@ -14,21 +14,16 @@ val module = SerializersModule {
 
 val format = Json { serializersModule = module }
 
-interface Project {
-    val name: String
+@Serializable
+abstract class Project {
+    abstract val name: String
 }
-
+            
 @Serializable
 @SerialName("owned")
-class OwnedProject(override val name: String, val owner: String) : Project
-
-@Serializable
-class Data(
-    @Polymorphic // the code does not compile without it 
-    val project: Any 
-)
+class OwnedProject(override val name: String, val owner: String) : Project()
 
 fun main() {
-    val data = Data(OwnedProject("kotlinx.coroutines", "kotlin"))
-    println(format.encodeToString(data))
-}
+    val data: Any = OwnedProject("kotlinx.coroutines", "kotlin")
+    println(format.encodeToString(PolymorphicSerializer(Any::class), data))
+}    
diff --git a/guide/example/example-poly-16.kt b/guide/example/example-poly-16.kt
index 079dc70cec..ef4f0e9cbc 100644
--- a/guide/example/example-poly-16.kt
+++ b/guide/example/example-poly-16.kt
@@ -5,15 +5,12 @@ import kotlinx.serialization.*
 import kotlinx.serialization.json.*
 
 import kotlinx.serialization.modules.*
-import kotlin.reflect.KClass
 
 val module = SerializersModule {
-    fun PolymorphicModuleBuilder<Project>.registerProjectSubclasses() {
+    polymorphic(Any::class) {
         subclass(OwnedProject::class)
     }
-    polymorphic(Any::class) { registerProjectSubclasses() }
-    polymorphic(Project::class) { registerProjectSubclasses() }
-}        
+}
 
 val format = Json { serializersModule = module }
 
@@ -27,12 +24,11 @@ class OwnedProject(override val name: String, val owner: String) : Project
 
 @Serializable
 class Data(
-    val project: Project,
-    @Polymorphic val any: Any 
+    @Polymorphic // the code does not compile without it 
+    val project: Any 
 )
 
 fun main() {
-    val project = OwnedProject("kotlinx.coroutines", "kotlin")
-    val data = Data(project, project)
+    val data = Data(OwnedProject("kotlinx.coroutines", "kotlin"))
     println(format.encodeToString(data))
-}        
+}
diff --git a/guide/example/example-poly-17.kt b/guide/example/example-poly-17.kt
index 0b15a15934..c928d7c586 100644
--- a/guide/example/example-poly-17.kt
+++ b/guide/example/example-poly-17.kt
@@ -5,44 +5,34 @@ import kotlinx.serialization.*
 import kotlinx.serialization.json.*
 
 import kotlinx.serialization.modules.*
+import kotlin.reflect.KClass
 
-@Serializable
-abstract class Response<out T>
-            
-@Serializable
-@SerialName("OkResponse")
-data class OkResponse<out T>(val data: T) : Response<T>()
-
-val responseModule = SerializersModule {
-    polymorphic(Response::class) {
-        subclass(OkResponse.serializer(PolymorphicSerializer(Any::class)))
-    }
-}
-
-val projectModule = SerializersModule {
+val module = SerializersModule {
     fun PolymorphicModuleBuilder<Project>.registerProjectSubclasses() {
         subclass(OwnedProject::class)
     }
     polymorphic(Any::class) { registerProjectSubclasses() }
     polymorphic(Project::class) { registerProjectSubclasses() }
-}
+}        
 
-@Serializable
-abstract class Project {
-    abstract val name: String
+val format = Json { serializersModule = module }
+
+interface Project {
+    val name: String
 }
-            
+
 @Serializable
-@SerialName("OwnedProject")
-data class OwnedProject(override val name: String, val owner: String) : Project()
+@SerialName("owned")
+class OwnedProject(override val name: String, val owner: String) : Project
 
-val format = Json { serializersModule = projectModule + responseModule }
+@Serializable
+class Data(
+    val project: Project,
+    @Polymorphic val any: Any 
+)
 
 fun main() {
-    // both Response and Project are abstract and their concrete subtypes are being serialized
-    val data: Response<Project> =  OkResponse(OwnedProject("kotlinx.serialization", "kotlin"))
-    val string = format.encodeToString(data)
-    println(string)
-    println(format.decodeFromString<Response<Project>>(string))
-}
-
+    val project = OwnedProject("kotlinx.coroutines", "kotlin")
+    val data = Data(project, project)
+    println(format.encodeToString(data))
+}        
diff --git a/guide/example/example-poly-18.kt b/guide/example/example-poly-18.kt
index 18ac3ec64a..54048c6210 100644
--- a/guide/example/example-poly-18.kt
+++ b/guide/example/example-poly-18.kt
@@ -6,25 +6,43 @@ import kotlinx.serialization.json.*
 
 import kotlinx.serialization.modules.*
 
+@Serializable
+abstract class Response<out T>
+            
+@Serializable
+@SerialName("OkResponse")
+data class OkResponse<out T>(val data: T) : Response<T>()
+
+val responseModule = SerializersModule {
+    polymorphic(Response::class) {
+        subclass(OkResponse.serializer(PolymorphicSerializer(Any::class)))
+    }
+}
+
+val projectModule = SerializersModule {
+    fun PolymorphicModuleBuilder<Project>.registerProjectSubclasses() {
+        subclass(OwnedProject::class)
+    }
+    polymorphic(Any::class) { registerProjectSubclasses() }
+    polymorphic(Project::class) { registerProjectSubclasses() }
+}
+
 @Serializable
 abstract class Project {
     abstract val name: String
 }
-
+            
 @Serializable
 @SerialName("OwnedProject")
 data class OwnedProject(override val name: String, val owner: String) : Project()
 
-val module = SerializersModule {
-    polymorphic(Project::class) {
-        subclass(OwnedProject::class)
-    }
-}
-
-val format = Json { serializersModule = module }
+val format = Json { serializersModule = projectModule + responseModule }
 
 fun main() {
-    println(format.decodeFromString<Project>("""
-        {"type":"unknown","name":"example"}
-    """))
+    // both Response and Project are abstract and their concrete subtypes are being serialized
+    val data: Response<Project> =  OkResponse(OwnedProject("kotlinx.serialization", "kotlin"))
+    val string = format.encodeToString(data)
+    println(string)
+    println(format.decodeFromString<Response<Project>>(string))
 }
+
diff --git a/guide/example/example-poly-19.kt b/guide/example/example-poly-19.kt
index 83677ebe47..d621a58c3a 100644
--- a/guide/example/example-poly-19.kt
+++ b/guide/example/example-poly-19.kt
@@ -11,9 +11,6 @@ abstract class Project {
     abstract val name: String
 }
 
-@Serializable
-data class BasicProject(override val name: String, val type: String): Project()
-
 @Serializable
 @SerialName("OwnedProject")
 data class OwnedProject(override val name: String, val owner: String) : Project()
@@ -21,17 +18,13 @@ data class OwnedProject(override val name: String, val owner: String) : Project(
 val module = SerializersModule {
     polymorphic(Project::class) {
         subclass(OwnedProject::class)
-        defaultDeserializer { BasicProject.serializer() }
     }
 }
 
 val format = Json { serializersModule = module }
 
 fun main() {
-    println(format.decodeFromString<List<Project>>("""
-        [
-            {"type":"unknown","name":"example"},
-            {"type":"OwnedProject","name":"kotlinx.serialization","owner":"kotlin"} 
-        ]
+    println(format.decodeFromString<Project>("""
+        {"type":"unknown","name":"example"}
     """))
 }
diff --git a/guide/example/example-poly-20.kt b/guide/example/example-poly-20.kt
index b597fbeb3d..d86a915b89 100644
--- a/guide/example/example-poly-20.kt
+++ b/guide/example/example-poly-20.kt
@@ -4,71 +4,34 @@ package example.examplePoly20
 import kotlinx.serialization.*
 import kotlinx.serialization.json.*
 
-import kotlinx.serialization.descriptors.*
-import kotlinx.serialization.encoding.*
 import kotlinx.serialization.modules.*
 
-interface Animal {
+@Serializable
+abstract class Project {
+    abstract val name: String
 }
 
-interface Cat : Animal {
-    val catType: String
-}
-
-interface Dog : Animal {
-    val dogType: String
-}
-
-private class CatImpl : Cat {
-    override val catType: String = "Tabby"
-}
-
-private class DogImpl : Dog {
-    override val dogType: String = "Husky"
-}
+@Serializable
+data class BasicProject(override val name: String, val type: String): Project()
 
-object AnimalProvider {
-    fun createCat(): Cat = CatImpl()
-    fun createDog(): Dog = DogImpl()
-}
+@Serializable
+@SerialName("OwnedProject")
+data class OwnedProject(override val name: String, val owner: String) : Project()
 
 val module = SerializersModule {
-    polymorphicDefaultSerializer(Animal::class) { instance ->
-        @Suppress("UNCHECKED_CAST")
-        when (instance) {
-            is Cat -> CatSerializer as SerializationStrategy<Animal>
-            is Dog -> DogSerializer as SerializationStrategy<Animal>
-            else -> null
-        }
-    }
-}
-
-object CatSerializer : SerializationStrategy<Cat> {
-    override val descriptor = buildClassSerialDescriptor("Cat") {
-        element<String>("catType")
-    }
-  
-    override fun serialize(encoder: Encoder, value: Cat) {
-        encoder.encodeStructure(descriptor) {
-          encodeStringElement(descriptor, 0, value.catType)
-        }
-    }
-}
-
-object DogSerializer : SerializationStrategy<Dog> {
-  override val descriptor = buildClassSerialDescriptor("Dog") {
-    element<String>("dogType")
-  }
-
-  override fun serialize(encoder: Encoder, value: Dog) {
-    encoder.encodeStructure(descriptor) {
-      encodeStringElement(descriptor, 0, value.dogType)
+    polymorphic(Project::class) {
+        subclass(OwnedProject::class)
+        defaultDeserializer { BasicProject.serializer() }
     }
-  }
 }
 
 val format = Json { serializersModule = module }
 
 fun main() {
-    println(format.encodeToString<Animal>(AnimalProvider.createCat()))
+    println(format.decodeFromString<List<Project>>("""
+        [
+            {"type":"unknown","name":"example"},
+            {"type":"OwnedProject","name":"kotlinx.serialization","owner":"kotlin"} 
+        ]
+    """))
 }
diff --git a/guide/example/example-poly-21.kt b/guide/example/example-poly-21.kt
new file mode 100644
index 0000000000..666fdffab5
--- /dev/null
+++ b/guide/example/example-poly-21.kt
@@ -0,0 +1,74 @@
+// This file was automatically generated from polymorphism.md by Knit tool. Do not edit.
+package example.examplePoly21
+
+import kotlinx.serialization.*
+import kotlinx.serialization.json.*
+
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+import kotlinx.serialization.modules.*
+
+interface Animal {
+}
+
+interface Cat : Animal {
+    val catType: String
+}
+
+interface Dog : Animal {
+    val dogType: String
+}
+
+private class CatImpl : Cat {
+    override val catType: String = "Tabby"
+}
+
+private class DogImpl : Dog {
+    override val dogType: String = "Husky"
+}
+
+object AnimalProvider {
+    fun createCat(): Cat = CatImpl()
+    fun createDog(): Dog = DogImpl()
+}
+
+val module = SerializersModule {
+    polymorphicDefaultSerializer(Animal::class) { instance ->
+        @Suppress("UNCHECKED_CAST")
+        when (instance) {
+            is Cat -> CatSerializer as SerializationStrategy<Animal>
+            is Dog -> DogSerializer as SerializationStrategy<Animal>
+            else -> null
+        }
+    }
+}
+
+object CatSerializer : SerializationStrategy<Cat> {
+    override val descriptor = buildClassSerialDescriptor("Cat") {
+        element<String>("catType")
+    }
+  
+    override fun serialize(encoder: Encoder, value: Cat) {
+        encoder.encodeStructure(descriptor) {
+          encodeStringElement(descriptor, 0, value.catType)
+        }
+    }
+}
+
+object DogSerializer : SerializationStrategy<Dog> {
+  override val descriptor = buildClassSerialDescriptor("Dog") {
+    element<String>("dogType")
+  }
+
+  override fun serialize(encoder: Encoder, value: Dog) {
+    encoder.encodeStructure(descriptor) {
+      encodeStringElement(descriptor, 0, value.dogType)
+    }
+  }
+}
+
+val format = Json { serializersModule = module }
+
+fun main() {
+    println(format.encodeToString<Animal>(AnimalProvider.createCat()))
+}
diff --git a/guide/test/PolymorphismTest.kt b/guide/test/PolymorphismTest.kt
index 344ed24dab..dc9e04cec6 100644
--- a/guide/test/PolymorphismTest.kt
+++ b/guide/test/PolymorphismTest.kt
@@ -73,23 +73,23 @@ class PolymorphismTest {
 
     @Test
     fun testExamplePoly10() {
-        captureOutput("ExamplePoly10") { example.examplePoly10.main() }.verifyOutputLinesStart(
+        captureOutput("ExamplePoly10") { example.examplePoly10.main() }.verifyOutputLines(
             "{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}"
         )
     }
 
     @Test
     fun testExamplePoly11() {
-        captureOutput("ExamplePoly11") { example.examplePoly11.main() }.verifyOutputLines(
-            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
+        captureOutput("ExamplePoly11") { example.examplePoly11.main() }.verifyOutputLinesStart(
+            "{\"type\":\"example.examplePoly11.Sub1\",\"data\":\"kotlin\"}",
+            "{\"type\":\"example.examplePoly11.Sub1\",\"data\":\"kotlin\"}"
         )
     }
 
     @Test
     fun testExamplePoly12() {
-        captureOutput("ExamplePoly12") { example.examplePoly12.main() }.verifyOutputLinesStart(
-            "Exception in thread \"main\" kotlinx.serialization.SerializationException: Serializer for class 'Any' is not found.",
-            "Please ensure that class is marked as '@Serializable' and that the serialization compiler plugin is applied."
+        captureOutput("ExamplePoly12") { example.examplePoly12.main() }.verifyOutputLines(
+            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
         )
     }
 
@@ -103,51 +103,59 @@ class PolymorphismTest {
 
     @Test
     fun testExamplePoly14() {
-        captureOutput("ExamplePoly14") { example.examplePoly14.main() }.verifyOutputLines(
-            "{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}"
+        captureOutput("ExamplePoly14") { example.examplePoly14.main() }.verifyOutputLinesStart(
+            "Exception in thread \"main\" kotlinx.serialization.SerializationException: Serializer for class 'Any' is not found.",
+            "Please ensure that class is marked as '@Serializable' and that the serialization compiler plugin is applied."
         )
     }
 
     @Test
     fun testExamplePoly15() {
         captureOutput("ExamplePoly15") { example.examplePoly15.main() }.verifyOutputLines(
-            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
+            "{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}"
         )
     }
 
     @Test
     fun testExamplePoly16() {
         captureOutput("ExamplePoly16") { example.examplePoly16.main() }.verifyOutputLines(
-            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"},\"any\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
+            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
         )
     }
 
     @Test
     fun testExamplePoly17() {
         captureOutput("ExamplePoly17") { example.examplePoly17.main() }.verifyOutputLines(
+            "{\"project\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"},\"any\":{\"type\":\"owned\",\"name\":\"kotlinx.coroutines\",\"owner\":\"kotlin\"}}"
+        )
+    }
+
+    @Test
+    fun testExamplePoly18() {
+        captureOutput("ExamplePoly18") { example.examplePoly18.main() }.verifyOutputLines(
             "{\"type\":\"OkResponse\",\"data\":{\"type\":\"OwnedProject\",\"name\":\"kotlinx.serialization\",\"owner\":\"kotlin\"}}",
             "OkResponse(data=OwnedProject(name=kotlinx.serialization, owner=kotlin))"
         )
     }
 
     @Test
-    fun testExamplePoly18() {
-        captureOutput("ExamplePoly18") { example.examplePoly18.main() }.verifyOutputLinesStart(
+    fun testExamplePoly19() {
+        captureOutput("ExamplePoly19") { example.examplePoly19.main() }.verifyOutputLinesStart(
             "Exception in thread \"main\" kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 0: Serializer for subclass 'unknown' is not found in the polymorphic scope of 'Project' at path: $",
             "Check if class with serial name 'unknown' exists and serializer is registered in a corresponding SerializersModule."
         )
     }
 
     @Test
-    fun testExamplePoly19() {
-        captureOutput("ExamplePoly19") { example.examplePoly19.main() }.verifyOutputLines(
+    fun testExamplePoly20() {
+        captureOutput("ExamplePoly20") { example.examplePoly20.main() }.verifyOutputLines(
             "[BasicProject(name=example, type=unknown), OwnedProject(name=kotlinx.serialization, owner=kotlin)]"
         )
     }
 
     @Test
-    fun testExamplePoly20() {
-        captureOutput("ExamplePoly20") { example.examplePoly20.main() }.verifyOutputLines(
+    fun testExamplePoly21() {
+        captureOutput("ExamplePoly21") { example.examplePoly21.main() }.verifyOutputLines(
             "{\"type\":\"Cat\",\"catType\":\"Tabby\"}"
         )
     }