diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..a53582c
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: DockyardMC
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: LukynkaCZE
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..b46a3ca
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,50 @@
+name: Test
+
+permissions:
+  actions: write
+  checks: write
+  contents: write
+  deployments: write
+  issues: write
+  packages: write
+  pull-requests: write
+  repository-projects: write
+  security-events: write
+  statuses: write
+
+on:
+  push:
+    branches: [ "main" ]
+
+  pull_request:
+    branches: [ "**" ]
+
+  workflow_dispatch:
+
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v3
+
+      - name: Add execute permissions for gradlew
+        run: chmod +x gradlew
+
+      - name: Build with Gradle
+        run: ./gradlew build test
+
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v4
+        if: success() || failure() # always run even if the previous step fails
+        with:
+          report_paths: '**/build/test-results/test/TEST-*.xml'
\ No newline at end of file
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 75711b8..7a6776e 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -2,6 +2,7 @@
   <profile version="1.0">
     <option name="myName" value="Project Default" />
     <inspection_tool class="95157777-0033-37fe-804b-48a99dd6dd21" enabled="true" level="ERROR" enabled_by_default="true" editorAttributes="ERRORS_ATTRIBUTES" />
+    <inspection_tool class="MemberVisibilityCanBePrivate" enabled="false" level="WEAK WARNING" enabled_by_default="false" />
     <inspection_tool class="RedundantCompanionReference" enabled="true" level="INFORMATION" enabled_by_default="true" editorAttributes="INFORMATION_ATTRIBUTES" />
     <inspection_tool class="RedundantExplicitType" enabled="true" level="INFORMATION" enabled_by_default="true" editorAttributes="INFORMATION_ATTRIBUTES" />
     <inspection_tool class="RemoveCurlyBracesFromTemplate" enabled="true" level="WARNING" enabled_by_default="true" editorAttributes="WARNING_ATTRIBUTES" />
diff --git a/README.md b/README.md
index 1221d3d..1affd07 100644
--- a/README.md
+++ b/README.md
@@ -7,134 +7,93 @@
 [![Discord](https://img.shields.io/discord/1242845647892123650?label=Discord%20Server&color=%237289DA&style=for-the-badge&logo=discord&logoColor=%23FFFFFF)](https://discord.gg/SA9nmfMkdc)
 [![Static Badge](https://img.shields.io/badge/Donate-Ko--Fi-pink?style=for-the-badge&logo=ko-fi&logoColor=%23FFFFFF&color=%23ff70c8)](https://ko-fi.com/LukynkaCZE)
 
-Tide is a Kotlin codec library that allows for serializing to network protocol and JSON while allowing other formats to be integrated via use custom Transcoders. 
+Tide is a Kotlin Codecs library inspired by Mojang's [DataFixerUpper](https://github.com/Mojang/DataFixerUpper) that
+allows for serializing both network and custom objects via use of transcoders (Json, NBT, etc.)
 
-It is purpose built for the [DockyardMC](https://github.com/DockyardMC/Dockyard) project which is reimplementation of the Minecraft server protocol so **some primitive types like **`Strings`**, **`Lists`** and **`Maps`** are not using the standard format, but they are following the Minecraft protocol's implementation**
+It is purpose built for the [DockyardMC](https://github.com/DockyardMC/Dockyard) project which is reimplementation of
+the Minecraft server protocol so **some primitive types like **`Strings`**, **`Lists`** and **`Maps`** are not using the
+standard format, but they are following the Minecraft protocol's implementation**
 
 ## Installation
 
 <img src="https://cdn.worldvectorlogo.com/logos/kotlin-2.svg" width="16px"></img>
 **Kotlin DSL**
+
 ```kotlin
 repositories {
-    maven {
-        name = "devOS"
-        url = uri("https://mvn.devos.one/releases")
-    }
+    maven("https://mvn.devos.one/releases")
 }
 
 dependencies {
-    implementation("io.github.dockyardmc:tide:1.7")
+    implementation("io.github.dockyardmc:tide:<version>")
 }
 ```
+
 ---
 
 ## Usage
 
 You can create a codec like this:
-```kotlin
-data class Person(val name: String, val age: Int) {
-    companion object {
-        val codec = Codec.of<Person> {
-            field("name", Primitives.String, Person::name)
-            field("age", Primitives.Int, Person::age)
-        }
-    }
-}
-```
-You can either serialize it into a network type by calling the `Codec#writeNetwork` or into json by calling `Codec#writeJson`
-
----
-
-You can include other codecs inside a codec to create more complex types:
 
 ```kotlin
-data class Bus(val model: String, val driver: Person, val passengers: List<Person>) {
+data class Player(val username: String, val uuid: UUID) {
     companion object {
-        val codec = Codec.of<Bus> {
-            field("name", Primitives.String, Bus::model)
-            field("driver", Person.codec, Bus::driver)
-            field("passengers", Person.codec.list(), Bus::passengers)
-        }
+        // Network serialization into netty ByteBuf
+        val STREAM_CODEC = StreamCodec.of(
+            StreamCodec.STRING, Player::username,
+            StreamCodec.UUID, Player::uuid,
+            ::Player
+        )
+
+        // Custom serialization into JSON, NBT, etc.
+        val CODEC = StructCodec.of(
+            "username", Codec.STRING, Player::username,
+            "uuid", Codec.UUID, Player::uuid,
+            ::Player
+        )
     }
 }
 ```
 
----
-
-To use lists you can simply call `Codec#list` on existing codec like this:
-
+And then you can either use the `STREAM_CODEC` to write to network buffer:
 ```kotlin
-data class Book(val pages: List<String>) {
-    companion object {
-        val codec = Codec.of<Book> {
-            field("pages", Primitives.String.list(), Book::pages)
-        }
-    }
+fun writeToNetwork() {
+    val buffer = Unpooled.buffer()
+    val player = Player("LukynkaCZE", UUID.fromString("0c9151e4-7083-418d-a29c-bbc58f7c741b"))
+    Player.STREAM_CODEC.write(buffer, player)
 }
 ```
-
----
-
-To use maps, you can either use `Codec#mapAsKeyTo` which will create map of the current codec as key and provided codec as value or Codec#mapAsValueTo which will use the current coded as value and provided coded as key:
-
+or use the `CODEC` to write to custom format:
 ```kotlin
-data class WarehouseInventory(val iceCreamFlavours: Map<String, Int>, val cookieFlavours: Map<String, Int>) {
-    companion object {
-        val codec = Codec.of<WarehouseInventory> {
-            field("ice_cream_flavours", Primitives.String.mapAsKeyTo(Primitives.VarInt), WarehouseInventory::iceCreamFlavours) //uses current as key of the map 
-            field("cookie_flavours", Primitives.Int.mapAsValueTo(Primitives.String), WarehouseInventory::cookieFlavours) // uses current as value of the map
-        }
-    }
+fun writeJson() {
+    val player = Player("LukynkaCZE", UUID.randomUUID())
+    val json = Player.CODEC.encode(JsonTranscoder, player)
 }
 ```
 
 ---
 
-Optionals are Minecraft protocol specific type. They represent the Java `Optional<T>` class. Optionals in protocol consist of a `boolean` field which indicates if the value is present or not and the actual value. To make things simple, Tide returns **nullable values** instead of the java `Optional<T>` classes
-
-You can use the `Codec#optional` to make the field optional:
+You can include other codecs inside a codec to create more complex types:
 
 ```kotlin
-data class Book(val pages: List<String>, val synopsis: String?) {
+data class Bus(val model: String, val driver: Player, val passengers: List<Player>) {
     companion object {
-        val codec = Codec.of<Book> {
-            field("pages", Primitives.String.list(), Book::pages)
-            field("synopsis", Primitives.String.optional(), Book::synopsis)
-        }
+        val STREAM_CODEC = StreamCodec.of(
+            StreamCodec.STRING, Bus::model,
+            Player.STREAM_CODEC, Bus::driver,
+            Player.STREAM_CODEC.list(), Bus::passengers,
+            ::Bus
+        )
+
+        val CODEC = StructCodec.of(
+            "model", Codec.STRING, Bus::model,
+            "driver", Player.CODEC, Bus::driver,
+            "passengers", Player.CODEC.list(), Bus::passengers,
+            ::Bus
+        )
     }
 }
 ```
-
 ---
 
-Enums are a special case because in the Minecraft protocol they are represented by VarInt type which is a variable length integer. The value is the ordinal (the index in the entries) of the enum value
-
-You will need to use `Codec#enum` to create this codec which has a class field to provide the class of the enum for inner reflection shenanigans:
-
-```kotlin
-data class Book(val pages: List<String>, val synopsis: String?, val type: Book.Type) {
-
-    enum class Type {
-        HORROR,
-        SCI_FI,
-        MEDIEVAL,
-        FANTASY,
-        FICTION,
-        ADVENTURE,
-        THRILLER,
-        MANGA,
-        HENTAI
-    }
-
-    companion object {
-        val codec = Codec.of<Book> {
-            field("pages", Primitives.String.list(), Book::pages)
-            field("synopsis", Primitives.String.optional(), Book::synopsis)
-            field("type", Codec.enum(Book.Type::class), Book::type)
-        }
-    }
-}
-```
-
-
+You can also easily implement your own Transcoders by implementing the `Transcoder` interface
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index 407a97b..ea57394 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -23,7 +23,6 @@ dependencies {
     implementation("cz.lukynka:pretty-log:1.5")
     api("io.ktor:ktor-server-netty:3.1.2")
     api("com.google.code.gson:gson:2.13.0")
-    implementation("com.moandjiezana.toml:toml4j:0.7.2")
 }
 
 tasks.test {
diff --git a/gradle.properties b/gradle.properties
index c9d2bb5..2ef6fe2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,2 +1,2 @@
 kotlin.code.style=official
-tide.version=1.7
\ No newline at end of file
+tide.version=3.0
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/Codec.kt b/src/main/kotlin/io/github/dockyardmc/tide/Codec.kt
deleted file mode 100644
index d9242c1..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/Codec.kt
+++ /dev/null
@@ -1,2555 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import cz.lukynka.prettylog.LogType
-import cz.lukynka.prettylog.log
-import io.netty.buffer.ByteBuf
-import java.util.concurrent.atomic.AtomicInteger
-import kotlin.reflect.KClass
-import kotlin.reflect.full.companionObject
-import kotlin.system.measureTimeMillis
-
-
-/**
- * Codec represents combined encoder and decoder functions for a given value
- *
- * <p>Heavily inspired by <a href="https://github.com/Mojang/DataFixerUpper">Mojang/DataFixerUpper</a>,
- * licensed under the MIT license.</p>
- *
- * @param T The type representing this codec
- */
-interface Codec<T> {
-
-    /**
-     * Writes a given value as network type into a buffer
-     *
-     * @param buffer the buffer the value will be written to
-     * @param value the value
-     */
-    fun writeNetwork(buffer: ByteBuf, value: T)
-
-    /**
-     * Reads value from a buffer
-     *
-     * @param buffer
-     * @return [T]
-     */
-    fun readNetwork(buffer: ByteBuf): T
-
-    /**
-     * Writes a given value as JSON into a [JsonElement]
-     *
-     * @param json existing json object
-     * @param value value
-     * @param field field name the value will be written under. If left empty, it's written as root node
-     */
-    fun writeJson(json: JsonElement, value: T, field: String)
-
-    /**
-     * Reads a value from json
-     *
-     * @param json existing [JsonElement]
-     * @param field field name the value will be read under. If left empty, it's read as root node
-     * @return [T]
-     */
-    fun readJson(json: JsonElement, field: String): T
-
-    /**
-     * Writes json as a root node into a JsonElement
-     *
-     * @param json
-     * @param value
-     */
-    fun writeJson(json: JsonElement, value: T) {
-        writeJson(json, value, "")  // Empty field here indicates root
-    }
-
-    /**
-     * Writes codec using provided custom [Transcoder]
-     *
-     * @param A
-     * @param transcoder
-     * @param format
-     * @param value
-     * @param field
-     */
-    fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: T, field: String)
-
-    /**
-     * Reads codec using provided custom [Transcoder]
-     *
-     * @param A
-     * @param transcoder
-     * @param format
-     * @param field
-     * @return [T]
-     */
-    fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): T
-
-    /**
-     * Reads a value from json as root node
-     *
-     * @param json
-     * @return
-     */
-    fun readJson(json: JsonElement): T {
-        return readJson(json, "") // Empty field here indicates root
-    }
-
-    /**
-     * Makes the field optional. Optional fields are internally prefixed with boolean which indicates if they are present or not (null)
-     *
-     * @return [OptionalCodec]
-     */
-    fun optional(): Codec<T?> {
-        return Companion.optional(this)
-    }
-
-    /**
-     * Turns the field into a [ListCodec]. Lists are internally prefixed with var int which indicates their length
-     *
-     * @return [ListCodec]
-     */
-    fun list(): Codec<List<T>> {
-        return Companion.list(this)
-    }
-
-    fun mutableList(): Codec<MutableList<T>> {
-        return Companion.mutableList(this)
-    }
-
-    /**
-     * Turns the field into a [MapCodec] of key (current field codec) and value (provided codec)
-     *
-     * @param V
-     * @param valueCodec
-     * @return [MapCodec]
-     */
-    fun <V> mapAsKeyTo(valueCodec: Codec<V>): Codec<Map<T, V>> {
-        return Companion.map(this, valueCodec)
-    }
-
-    fun <V> mutableMapAsKeyTo(valueCodec: Codec<V>): Codec<MutableMap<T, V>> {
-        return Companion.mutableMap(this, valueCodec)
-    }
-
-    /**
-     * Turns the field into a [MapCodec] of key (provided codec) and value (current field codec)
-     *
-     * @param K
-     * @param keyCodec
-     * @return [MapCodec]
-     */
-    fun <K> mapAsValueTo(keyCodec: Codec<K>): Codec<Map<K, T>> {
-        return Companion.map(keyCodec, this)
-    }
-
-    fun <K> mutableMapAsValueTo(keyCodec: Codec<K>): Codec<MutableMap<K, T>> {
-        return Companion.mutableMap(keyCodec, this)
-    }
-
-
-    companion object {
-
-        init {
-            val time = measureTimeMillis {
-                Codecs.Int
-                Codecs.Double
-                Codecs.Float
-                Codecs.UUID
-                Codecs.ByteArray
-                Codecs.Byte
-                Codecs.Boolean
-                Codecs.VarInt
-                Codecs.String
-                EnumCodec::class.companionObject
-                ListCodec::class.companionObject
-                MapCodec::class.companionObject
-                OptionalCodec::class.companionObject
-            }
-            log("\"Cache default codecs\" took ${time}ms", LogType.DEBUG)
-        }
-
-        val propertyCounter = AtomicInteger()
-
-        /**
-         * Creates [ListCodec] from the provided codec
-         *
-         * @param codec
-         * @return [ListCodec]
-         */
-        fun <T> list(codec: Codec<T>): Codec<List<T>> {
-            return ListCodec<T>(codec)
-        }
-
-        fun <T> mutableList(codec: Codec<T>): Codec<MutableList<T>> {
-            return MutableListCodec<T>(codec)
-        }
-
-        /**
-         * Creates [MapCodec] from the provided key and value codecs
-         *
-         * @param keyCodec
-         * @param valueCodec
-         * @return [MapCodec]
-         */
-        fun <K, V> map(keyCodec: Codec<K>, valueCodec: Codec<V>): Codec<Map<K, V>> {
-            return MapCodec<K, V>(keyCodec, valueCodec)
-        }
-
-        fun <K, V> mutableMap(keyCodec: Codec<K>, valueCodec: Codec<V>): Codec<MutableMap<K, V>> {
-            return MutableMapCodec<K, V>(keyCodec, valueCodec)
-        }
-
-
-        /**
-         * Creates [OptionalCodec] from the provided codec
-         *
-         * @param codec
-         * @return [OptionalCodec]
-         */
-        fun <T> optional(codec: Codec<T>): Codec<T?> {
-            return OptionalCodec<T>(codec)
-        }
-
-        /**
-         * Creates [EnumCodec] from the provided class
-         *
-         * @param kClass
-         * @return [EnumCodec]
-         */
-
-        inline fun <reified T> enum(): EnumCodec<T> {
-            return EnumCodec<T>(T::class as KClass<out Enum<*>>)
-        }
-
-
-        fun <R, P1> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            constructor: (P1) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                return constructor.invoke(p1)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                return constructor.invoke(p1)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                return constructor.invoke(p1)
-            }
-
-        }
-
-
-        fun <R, P1, P2> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            constructor: (P1, P2) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                return constructor.invoke(p1, p2)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                return constructor.invoke(p1, p2)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                return constructor.invoke(p1, p2)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            constructor: (P1, P2, P3) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                return constructor.invoke(p1, p2, p3)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                return constructor.invoke(p1, p2, p3)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            constructor: (P1, P2, P3, P4) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                return constructor.invoke(p1, p2, p3, p4)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                return constructor.invoke(p1, p2, p3, p4)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            constructor: (P1, P2, P3, P4, P5) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                return constructor.invoke(p1, p2, p3, p4, p5)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                return constructor.invoke(p1, p2, p3, p4, p5)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            constructor: (P1, P2, P3, P4, P5, P6) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            constructor: (P1, P2, P3, P4, P5, P6, P7) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)
-            }
-
-        }
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                val p16 = codec16.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-                codec16.writeNetwork(buffer, getter16.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                val p16 = codec16.readTranscoded(transcoder, format, name16)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-                codec16.writeTranscoded(transcoder, format, getter16.invoke(value), name16)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                codec16.writeJson(nestedJson, getter16.invoke(value), name16)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                val p16 = codec16.readJson(jsonToReadFrom, name16)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
-            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                val p16 = codec16.readNetwork(buffer)
-                val p17 = codec17.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-                codec16.writeNetwork(buffer, getter16.invoke(value))
-                codec17.writeNetwork(buffer, getter17.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                val p16 = codec16.readTranscoded(transcoder, format, name16)
-                val p17 = codec17.readTranscoded(transcoder, format, name17)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-                codec16.writeTranscoded(transcoder, format, getter16.invoke(value), name16)
-                codec17.writeTranscoded(transcoder, format, getter17.invoke(value), name17)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                codec16.writeJson(nestedJson, getter16.invoke(value), name16)
-                codec17.writeJson(nestedJson, getter17.invoke(value), name17)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                val p16 = codec16.readJson(jsonToReadFrom, name16)
-                val p17 = codec17.readJson(jsonToReadFrom, name17)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
-            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
-            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                val p16 = codec16.readNetwork(buffer)
-                val p17 = codec17.readNetwork(buffer)
-                val p18 = codec18.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-                codec16.writeNetwork(buffer, getter16.invoke(value))
-                codec17.writeNetwork(buffer, getter17.invoke(value))
-                codec18.writeNetwork(buffer, getter18.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                val p16 = codec16.readTranscoded(transcoder, format, name16)
-                val p17 = codec17.readTranscoded(transcoder, format, name17)
-                val p18 = codec18.readTranscoded(transcoder, format, name18)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-                codec16.writeTranscoded(transcoder, format, getter16.invoke(value), name16)
-                codec17.writeTranscoded(transcoder, format, getter17.invoke(value), name17)
-                codec18.writeTranscoded(transcoder, format, getter18.invoke(value), name18)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                codec16.writeJson(nestedJson, getter16.invoke(value), name16)
-                codec17.writeJson(nestedJson, getter17.invoke(value), name17)
-                codec18.writeJson(nestedJson, getter18.invoke(value), name18)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                val p16 = codec16.readJson(jsonToReadFrom, name16)
-                val p17 = codec17.readJson(jsonToReadFrom, name17)
-                val p18 = codec18.readJson(jsonToReadFrom, name18)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18)
-            }
-
-        }
-
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
-            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
-            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
-            name19: String, codec19: Codec<P19>, getter19: (R) -> P19,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                val p16 = codec16.readNetwork(buffer)
-                val p17 = codec17.readNetwork(buffer)
-                val p18 = codec18.readNetwork(buffer)
-                val p19 = codec19.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-                codec16.writeNetwork(buffer, getter16.invoke(value))
-                codec17.writeNetwork(buffer, getter17.invoke(value))
-                codec18.writeNetwork(buffer, getter18.invoke(value))
-                codec19.writeNetwork(buffer, getter19.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                val p16 = codec16.readTranscoded(transcoder, format, name16)
-                val p17 = codec17.readTranscoded(transcoder, format, name17)
-                val p18 = codec18.readTranscoded(transcoder, format, name18)
-                val p19 = codec19.readTranscoded(transcoder, format, name19)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-                codec16.writeTranscoded(transcoder, format, getter16.invoke(value), name16)
-                codec17.writeTranscoded(transcoder, format, getter17.invoke(value), name17)
-                codec18.writeTranscoded(transcoder, format, getter18.invoke(value), name18)
-                codec19.writeTranscoded(transcoder, format, getter19.invoke(value), name19)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                codec16.writeJson(nestedJson, getter16.invoke(value), name16)
-                codec17.writeJson(nestedJson, getter17.invoke(value), name17)
-                codec18.writeJson(nestedJson, getter18.invoke(value), name18)
-                codec19.writeJson(nestedJson, getter19.invoke(value), name19)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                val p16 = codec16.readJson(jsonToReadFrom, name16)
-                val p17 = codec17.readJson(jsonToReadFrom, name17)
-                val p18 = codec18.readJson(jsonToReadFrom, name18)
-                val p19 = codec19.readJson(jsonToReadFrom, name19)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19)
-            }
-
-        }
-
-        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> of(
-            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
-            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
-            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
-            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
-            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
-            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
-            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
-            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
-            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
-            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
-            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
-            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
-            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
-            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
-            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
-            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
-            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
-            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
-            name19: String, codec19: Codec<P19>, getter19: (R) -> P19,
-            name20: String, codec20: Codec<P20>, getter20: (R) -> P20,
-            constructor: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R,
-        ): Codec<R> = object : Codec<R> {
-            override fun readNetwork(buffer: ByteBuf): R {
-                val p1 = codec1.readNetwork(buffer)
-                val p2 = codec2.readNetwork(buffer)
-                val p3 = codec3.readNetwork(buffer)
-                val p4 = codec4.readNetwork(buffer)
-                val p5 = codec5.readNetwork(buffer)
-                val p6 = codec6.readNetwork(buffer)
-                val p7 = codec7.readNetwork(buffer)
-                val p8 = codec8.readNetwork(buffer)
-                val p9 = codec9.readNetwork(buffer)
-                val p10 = codec10.readNetwork(buffer)
-                val p11 = codec11.readNetwork(buffer)
-                val p12 = codec12.readNetwork(buffer)
-                val p13 = codec13.readNetwork(buffer)
-                val p14 = codec14.readNetwork(buffer)
-                val p15 = codec15.readNetwork(buffer)
-                val p16 = codec16.readNetwork(buffer)
-                val p17 = codec17.readNetwork(buffer)
-                val p18 = codec18.readNetwork(buffer)
-                val p19 = codec19.readNetwork(buffer)
-                val p20 = codec20.readNetwork(buffer)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20)
-            }
-
-            override fun writeNetwork(buffer: ByteBuf, value: R) {
-                codec1.writeNetwork(buffer, getter1.invoke(value))
-                codec2.writeNetwork(buffer, getter2.invoke(value))
-                codec3.writeNetwork(buffer, getter3.invoke(value))
-                codec4.writeNetwork(buffer, getter4.invoke(value))
-                codec5.writeNetwork(buffer, getter5.invoke(value))
-                codec6.writeNetwork(buffer, getter6.invoke(value))
-                codec7.writeNetwork(buffer, getter7.invoke(value))
-                codec8.writeNetwork(buffer, getter8.invoke(value))
-                codec9.writeNetwork(buffer, getter9.invoke(value))
-                codec10.writeNetwork(buffer, getter10.invoke(value))
-                codec11.writeNetwork(buffer, getter11.invoke(value))
-                codec12.writeNetwork(buffer, getter12.invoke(value))
-                codec13.writeNetwork(buffer, getter13.invoke(value))
-                codec14.writeNetwork(buffer, getter14.invoke(value))
-                codec15.writeNetwork(buffer, getter15.invoke(value))
-                codec16.writeNetwork(buffer, getter16.invoke(value))
-                codec17.writeNetwork(buffer, getter17.invoke(value))
-                codec18.writeNetwork(buffer, getter18.invoke(value))
-                codec19.writeNetwork(buffer, getter19.invoke(value))
-                codec20.writeNetwork(buffer, getter20.invoke(value))
-            }
-
-            override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): R {
-                val p1 = codec1.readTranscoded(transcoder, format, name1)
-                val p2 = codec2.readTranscoded(transcoder, format, name2)
-                val p3 = codec3.readTranscoded(transcoder, format, name3)
-                val p4 = codec4.readTranscoded(transcoder, format, name4)
-                val p5 = codec5.readTranscoded(transcoder, format, name5)
-                val p6 = codec6.readTranscoded(transcoder, format, name6)
-                val p7 = codec7.readTranscoded(transcoder, format, name7)
-                val p8 = codec8.readTranscoded(transcoder, format, name8)
-                val p9 = codec9.readTranscoded(transcoder, format, name9)
-                val p10 = codec10.readTranscoded(transcoder, format, name10)
-                val p11 = codec11.readTranscoded(transcoder, format, name11)
-                val p12 = codec12.readTranscoded(transcoder, format, name12)
-                val p13 = codec13.readTranscoded(transcoder, format, name13)
-                val p14 = codec14.readTranscoded(transcoder, format, name14)
-                val p15 = codec15.readTranscoded(transcoder, format, name15)
-                val p16 = codec16.readTranscoded(transcoder, format, name16)
-                val p17 = codec17.readTranscoded(transcoder, format, name17)
-                val p18 = codec18.readTranscoded(transcoder, format, name18)
-                val p19 = codec19.readTranscoded(transcoder, format, name19)
-                val p20 = codec20.readTranscoded(transcoder, format, name20)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20)
-            }
-
-            override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: R, field: String) {
-                codec1.writeTranscoded(transcoder, format, getter1.invoke(value), name1)
-                codec2.writeTranscoded(transcoder, format, getter2.invoke(value), name2)
-                codec3.writeTranscoded(transcoder, format, getter3.invoke(value), name3)
-                codec4.writeTranscoded(transcoder, format, getter4.invoke(value), name4)
-                codec5.writeTranscoded(transcoder, format, getter5.invoke(value), name5)
-                codec6.writeTranscoded(transcoder, format, getter6.invoke(value), name6)
-                codec7.writeTranscoded(transcoder, format, getter7.invoke(value), name7)
-                codec8.writeTranscoded(transcoder, format, getter8.invoke(value), name8)
-                codec9.writeTranscoded(transcoder, format, getter9.invoke(value), name9)
-                codec10.writeTranscoded(transcoder, format, getter10.invoke(value), name10)
-                codec11.writeTranscoded(transcoder, format, getter11.invoke(value), name11)
-                codec12.writeTranscoded(transcoder, format, getter12.invoke(value), name12)
-                codec13.writeTranscoded(transcoder, format, getter13.invoke(value), name13)
-                codec14.writeTranscoded(transcoder, format, getter14.invoke(value), name14)
-                codec15.writeTranscoded(transcoder, format, getter15.invoke(value), name15)
-                codec16.writeTranscoded(transcoder, format, getter16.invoke(value), name16)
-                codec17.writeTranscoded(transcoder, format, getter17.invoke(value), name17)
-                codec18.writeTranscoded(transcoder, format, getter18.invoke(value), name18)
-                codec19.writeTranscoded(transcoder, format, getter19.invoke(value), name19)
-                codec20.writeTranscoded(transcoder, format, getter20.invoke(value), name20)
-            }
-
-            override fun writeJson(json: JsonElement, value: R, field: String) {
-                val nestedJson = JsonObject()
-                codec1.writeJson(nestedJson, getter1.invoke(value), name1)
-                codec2.writeJson(nestedJson, getter2.invoke(value), name2)
-                codec3.writeJson(nestedJson, getter3.invoke(value), name3)
-                codec4.writeJson(nestedJson, getter4.invoke(value), name4)
-                codec5.writeJson(nestedJson, getter5.invoke(value), name5)
-                codec6.writeJson(nestedJson, getter6.invoke(value), name6)
-                codec7.writeJson(nestedJson, getter7.invoke(value), name7)
-                codec8.writeJson(nestedJson, getter8.invoke(value), name8)
-                codec9.writeJson(nestedJson, getter9.invoke(value), name9)
-                codec10.writeJson(nestedJson, getter10.invoke(value), name10)
-                codec11.writeJson(nestedJson, getter11.invoke(value), name11)
-                codec12.writeJson(nestedJson, getter12.invoke(value), name12)
-                codec13.writeJson(nestedJson, getter13.invoke(value), name13)
-                codec14.writeJson(nestedJson, getter14.invoke(value), name14)
-                codec15.writeJson(nestedJson, getter15.invoke(value), name15)
-                codec16.writeJson(nestedJson, getter16.invoke(value), name16)
-                codec17.writeJson(nestedJson, getter17.invoke(value), name17)
-                codec18.writeJson(nestedJson, getter18.invoke(value), name18)
-                codec19.writeJson(nestedJson, getter19.invoke(value), name19)
-                codec20.writeJson(nestedJson, getter20.invoke(value), name20)
-                if (field.isEmpty()) {
-                    nestedJson.entrySet().forEach { (key, value) ->
-                        json.asObjectOrThrow().add(key, value)
-                    }
-                } else {
-                    json.asObjectOrThrow().add(field, nestedJson)
-                }
-            }
-
-            override fun readJson(json: JsonElement, field: String): R {
-                val jsonToReadFrom: JsonElement
-                if (field.isEmpty()) { // root node
-                    if (json !is JsonObject) throw IllegalStateException("JsonElement is not JsonObject, cannot write json as root node")
-                    jsonToReadFrom = json
-                } else {
-                    jsonToReadFrom = json.asObjectOrThrow().get(field) ?: throw IllegalStateException("[field: $field] get is somehow null ($json) (is object: ${json.isJsonObject}, is primitive: ${json.isJsonPrimitive}, is null: ${json.isJsonNull})")
-                }
-
-                val p1 = codec1.readJson(jsonToReadFrom, name1)
-                val p2 = codec2.readJson(jsonToReadFrom, name2)
-                val p3 = codec3.readJson(jsonToReadFrom, name3)
-                val p4 = codec4.readJson(jsonToReadFrom, name4)
-                val p5 = codec5.readJson(jsonToReadFrom, name5)
-                val p6 = codec6.readJson(jsonToReadFrom, name6)
-                val p7 = codec7.readJson(jsonToReadFrom, name7)
-                val p8 = codec8.readJson(jsonToReadFrom, name8)
-                val p9 = codec9.readJson(jsonToReadFrom, name9)
-                val p10 = codec10.readJson(jsonToReadFrom, name10)
-                val p11 = codec11.readJson(jsonToReadFrom, name11)
-                val p12 = codec12.readJson(jsonToReadFrom, name12)
-                val p13 = codec13.readJson(jsonToReadFrom, name13)
-                val p14 = codec14.readJson(jsonToReadFrom, name14)
-                val p15 = codec15.readJson(jsonToReadFrom, name15)
-                val p16 = codec16.readJson(jsonToReadFrom, name16)
-                val p17 = codec17.readJson(jsonToReadFrom, name17)
-                val p18 = codec18.readJson(jsonToReadFrom, name18)
-                val p19 = codec19.readJson(jsonToReadFrom, name19)
-                val p20 = codec20.readJson(jsonToReadFrom, name20)
-                return constructor.invoke(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20)
-            }
-
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/Codecs.kt b/src/main/kotlin/io/github/dockyardmc/tide/Codecs.kt
deleted file mode 100644
index f787934..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/Codecs.kt
+++ /dev/null
@@ -1,325 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonElement
-import cz.lukynka.prettylog.log
-import io.netty.buffer.ByteBuf
-import io.netty.handler.codec.DecoderException
-import java.nio.charset.StandardCharsets
-import java.util.*
-import kotlin.experimental.inv
-import kotlin.reflect.KClass
-
-object Codecs {
-
-    object Byte : Codec<kotlin.Byte> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Byte) {
-            buffer.writeByte(value.toInt())
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Byte {
-            return buffer.readByte()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Byte {
-            return json.getPrimitive<kotlin.Int>(field).toByte()
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Byte {
-            return transcoder.readByte(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Byte, field: kotlin.String) {
-            transcoder.writeByte(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Byte, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-    object Double : Codec<kotlin.Double> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Double) {
-            buffer.writeDouble(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Double {
-            return buffer.readDouble()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Double {
-            return json.getPrimitive<kotlin.Double>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Double {
-            return transcoder.readDouble(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Double, field: kotlin.String) {
-            transcoder.writeDouble(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Double, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-    object Float : Codec<kotlin.Float> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Float) {
-            buffer.writeFloat(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Float {
-            return buffer.readFloat()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Float {
-            return json.getPrimitive<kotlin.Float>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Float {
-            return transcoder.readFloat(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Float, field: kotlin.String) {
-            transcoder.writeFloat(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Float, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-    object Long : Codec<kotlin.Long> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Long) {
-            buffer.writeLong(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Long {
-            return buffer.readLong()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Long {
-            return json.getPrimitive<kotlin.Long>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Long {
-            return transcoder.readLong(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Long, field: kotlin.String) {
-            transcoder.writeLong(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Long, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-    object UUID : Codec<java.util.UUID> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: java.util.UUID) {
-            Long.writeNetwork(buffer, value.mostSignificantBits)
-            Long.writeNetwork(buffer, value.leastSignificantBits)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): java.util.UUID {
-            val most = Long.readNetwork(buffer)
-            val least = Long.readNetwork(buffer)
-            return UUID(most, least)
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): java.util.UUID {
-            return java.util.UUID.fromString(json.getPrimitive<kotlin.String>(field))
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): java.util.UUID {
-            return transcoder.readUUID(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: java.util.UUID, field: kotlin.String) {
-            transcoder.writeUUID(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: java.util.UUID, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value.toString())
-        }
-
-    }
-
-    object ByteArray : Codec<kotlin.ByteArray> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.ByteArray) {
-            VarInt.writeNetwork(buffer, value.size)
-            buffer.writeBytes(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.ByteArray {
-            val size = VarInt.readNetwork(buffer)
-            val readBytes = buffer.readBytes(size)
-            val byteArray = ByteArray(readBytes.readableBytes())
-            readBytes.readBytes(byteArray)
-            return byteArray
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.ByteArray {
-            return Base64.getDecoder().decode(json.getPrimitive<kotlin.String>(field))
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.ByteArray {
-            return transcoder.readByteArray(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.ByteArray, field: kotlin.String) {
-            transcoder.writeByteArray(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.ByteArray, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, Base64.getEncoder().encodeToString(value))
-        }
-
-    }
-
-    object VarInt : Codec<kotlin.Int> {
-        private const val SEGMENT_BITS: kotlin.Byte = 0x7F
-        private const val CONTINUE_BIT = 0x80
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Int) {
-            var varIntValue = value
-            while (true) {
-                if (varIntValue and SEGMENT_BITS.inv().toInt() == 0) {
-                    buffer.writeByte(varIntValue)
-                    return
-                }
-                buffer.writeByte(value and SEGMENT_BITS.toInt() or CONTINUE_BIT)
-                varIntValue = varIntValue ushr 7
-            }
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Int {
-            var value = 0
-            var position = 0
-            var currentByte: kotlin.Byte
-            while (buffer.isReadable) {
-                currentByte = buffer.readByte()
-                value = value or (currentByte.toInt() and SEGMENT_BITS.toInt() shl position)
-                if (currentByte.toInt() and CONTINUE_BIT == 0) break
-                position += 7
-                if (position >= 32) throw RuntimeException("VarInt is too big")
-            }
-            return value
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Int {
-            return json.getPrimitive<kotlin.Int>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Int {
-            return transcoder.readVarInt(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Int, field: kotlin.String) {
-            transcoder.writeVarInt(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Int, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-
-    }
-
-    object Boolean : Codec<kotlin.Boolean>{
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Boolean) {
-            buffer.writeBoolean(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Boolean {
-            return buffer.readBoolean()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Boolean {
-            return json.getPrimitive(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Boolean {
-            return transcoder.readBoolean(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Boolean, field: kotlin.String) {
-            transcoder.writeBoolean(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Boolean, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-
-    }
-
-    object String : Codec<kotlin.String> {
-
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.String) {
-
-            val utf8Bytes = value.toByteArray(StandardCharsets.UTF_8)
-            VarInt.writeNetwork(buffer, utf8Bytes.size)
-            buffer.writeBytes(utf8Bytes)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.String {
-            val maxSize = Short.MAX_VALUE * 3
-            val size = VarInt.readNetwork(buffer)
-            if (size > maxSize) throw DecoderException("The received string was longer than the allowed $maxSize ($size > $maxSize)")
-            if (size < 0) throw DecoderException("The received string's length was smaller than 0")
-            val string = buffer.toString(buffer.readerIndex(), size, StandardCharsets.UTF_8)
-            buffer.readerIndex(buffer.readerIndex() + size)
-            if (string.length > Short.MAX_VALUE) throw DecoderException("The received string was longer than the allowed (${string.length} > ${Short.MAX_VALUE})")
-            return string
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.String {
-            return json.getPrimitive<kotlin.String>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.String {
-            return transcoder.readString(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.String, field: kotlin.String) {
-            return transcoder.writeString(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.String, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-    object Int : Codec<kotlin.Int> {
-        override fun writeNetwork(buffer: ByteBuf, value: kotlin.Int) {
-            buffer.writeInt(value)
-        }
-
-        override fun readNetwork(buffer: ByteBuf): kotlin.Int {
-            return buffer.readInt()
-        }
-
-        override fun readJson(json: JsonElement, field: kotlin.String): kotlin.Int {
-            return json.getPrimitive<kotlin.Int>(field)
-        }
-
-        override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: kotlin.String): kotlin.Int {
-            return transcoder.readInt(format, field)
-        }
-
-        override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: kotlin.Int, field: kotlin.String) {
-            transcoder.writeInt(format, field, value)
-        }
-
-        override fun writeJson(json: JsonElement, value: kotlin.Int, field: kotlin.String) {
-            json.asObjectOrThrow().addProperty(field, value)
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/EnumCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/EnumCodec.kt
deleted file mode 100644
index dc2ca68..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/EnumCodec.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonElement
-import io.netty.buffer.ByteBuf
-import kotlin.reflect.KClass
-
-class EnumCodec<T>(val kClass: KClass<out Enum<*>>) : Codec<T> {
-
-    override fun readNetwork(buffer: ByteBuf): T {
-        val ordinal = Codecs.VarInt.readNetwork(buffer)
-        return kClass.java.enumConstants[ordinal] as T
-    }
-
-    override fun writeNetwork(buffer: ByteBuf, value: T) {
-        Codecs.VarInt.writeNetwork(buffer, (value as Enum<*>).ordinal)
-    }
-
-    override fun readJson(json: JsonElement, field: String): T {
-        val name = json.getPrimitive<String>(field)
-        return kClass.java.enumConstants.first { entry -> entry.name == name } as T
-    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): T {
-        return transcoder.readEnum<T>(kClass, format, field)
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: T, field: String) {
-        transcoder.writeEnum(kClass, format, field, value)
-    }
-
-    override fun writeJson(json: JsonElement, value: T, field: String) {
-        json.asObjectOrThrow().addProperty(field, (value as Enum<*>).name)
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/ExtendedJsonElement.kt b/src/main/kotlin/io/github/dockyardmc/tide/ExtendedJsonElement.kt
deleted file mode 100644
index 279044e..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/ExtendedJsonElement.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import com.google.gson.JsonPrimitive
-
-fun JsonElement.asObjectOrThrow(): JsonObject {
-    if (this !is JsonObject || !this.isJsonObject) throw IllegalStateException("JsonElement is not JsonObject")
-    return this
-}
-
-inline fun <reified T> JsonElement.getPrimitive(key: String): T {
-    return this.getPrimitiveOrNull(key) ?: throw IllegalStateException("Field with name $key was not found")
-}
-
-inline fun <reified T> JsonElement.getPrimitiveOrNull(key: String): T? {
-    val element: JsonElement
-
-    if(this is JsonPrimitive) {
-        return getJsonAsGeneric<T>(this)
-    }
-
-    if (key.isEmpty()) {
-        element = this
-    } else {
-        if (this !is JsonObject) throw IllegalStateException("this is not JsonObject")
-        if (!has(key)) return null
-        element = get(key)
-    }
-    return getJsonAsGeneric<T>(element)
-
-}
-
-inline fun <reified T> getJsonAsGeneric(element: JsonElement): T {
-    return when (T::class) {
-        String::class -> {
-            when {
-                element.isJsonPrimitive -> element.asString
-                else -> element.toString()
-            } as T
-        }
-
-        Int::class -> element.asInt as T
-        Long::class -> element.asLong as T
-        Double::class -> element.asDouble as T
-        Float::class -> element.asFloat as T
-        Boolean::class -> element.asBoolean as T
-        JsonObject::class -> element.asJsonObject as T
-        JsonElement::class -> element as T
-        else -> throw UnsupportedOperationException("Type ${T::class} is not supported")
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/Field.kt b/src/main/kotlin/io/github/dockyardmc/tide/Field.kt
deleted file mode 100644
index b6adc0f..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/Field.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package io.github.dockyardmc.tide
-
-/**
- * A [Codec] field
- *
- * @param T The type of object this field is for
- * @property name Name of the field. Used for serializing JSON and NBT
- * @property codec [Codec] of the field which is used to [Codec.readNetwork] or [Codec.writeNetwork]
- * @property getter Reference to the class field in the class constructor (Example: Person::name)
- */
-class Field<T>(val name: String, val codec: Codec<*>, val getter: (T) -> Any?)
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/ListCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/ListCodec.kt
deleted file mode 100644
index 00c6420..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/ListCodec.kt
+++ /dev/null
@@ -1,80 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonArray
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import cz.lukynka.prettylog.log
-import io.netty.buffer.ByteBuf
-import kotlin.reflect.KClass
-
-class ListCodec<T>(val elementCodec: Codec<T>) : Codec<List<T>> {
-
-    override fun readNetwork(buffer: ByteBuf): List<T> {
-        val inner = mutableListOf<T>()
-        val size = Codecs.VarInt.readNetwork(buffer)
-        for (i in 0 until size) {
-            inner.add(elementCodec.readNetwork(buffer))
-        }
-        return inner.toList()
-    }
-
-    override fun writeNetwork(buffer: ByteBuf, value: List<T>) {
-        Codecs.VarInt.writeNetwork(buffer, value.size)
-        value.forEach { element ->
-            elementCodec.writeNetwork(buffer, element)
-        }
-    }
-
-    override fun readJson(json: JsonElement, field: String): List<T> {
-        val list = mutableListOf<T>()
-
-        if(field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot read json as root node")
-            json.forEach { element ->
-                list.add(elementCodec.readJson(element))
-            }
-            return list
-        }
-
-        val jsonObject = json.asObjectOrThrow()
-        if (!jsonObject.has(field)) {
-            throw IllegalArgumentException("Field '$field' does not exist in current json: $jsonObject")
-        }
-
-        val element = jsonObject.get(field) ?: throw IllegalArgumentException("Field `$field` does not exist in current json: $jsonObject!")
-        if(!element.isJsonArray) throw IllegalArgumentException("Field `$field` is not json array element! (json: $jsonObject)")
-        val jsonArray = element.asJsonArray!!
-
-        jsonArray.forEach { child ->
-            list.add(elementCodec.readJson(child))
-        }
-
-        return list
-    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): List<T> {
-        return transcoder.readList(format, field, elementCodec)
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: List<T>, field: String) {
-        transcoder.writeList(format, field, value, elementCodec)
-    }
-
-    override fun writeJson(json: JsonElement, value: List<T>, field: String) {
-        var arrayToWriteTo: JsonArray = JsonArray()
-
-        if (field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            arrayToWriteTo = json
-        }
-
-        value.forEach { element ->
-            val tempObj = JsonObject()
-            elementCodec.writeJson(tempObj, element, "value")
-            val elementValue = tempObj.get("value")
-            arrayToWriteTo.add(elementValue)
-        }
-
-        if (json is JsonObject) json.add(field, arrayToWriteTo)
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/MapCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/MapCodec.kt
deleted file mode 100644
index 06ee7ee..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/MapCodec.kt
+++ /dev/null
@@ -1,97 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonArray
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import cz.lukynka.prettylog.LogType
-import cz.lukynka.prettylog.log
-import io.netty.buffer.ByteBuf
-import kotlin.reflect.KClass
-
-class MapCodec<K, V>(private val keyCodec: Codec<K>, private val valueCodec: Codec<V>) : Codec<Map<K, V>> {
-
-    override fun writeNetwork(buffer: ByteBuf, value: Map<K, V>) {
-        Codecs.VarInt.writeNetwork(buffer, value.size)
-        value.forEach { (key, value) ->
-            keyCodec.writeNetwork(buffer, key)
-            valueCodec.writeNetwork(buffer, value)
-        }
-    }
-
-    override fun readNetwork(buffer: ByteBuf): Map<K, V> {
-        val map = mutableMapOf<K, V>()
-        val size = Codecs.VarInt.readNetwork(buffer)
-        for (i in 0 until size) {
-            val key = keyCodec.readNetwork(buffer)
-            val value = valueCodec.readNetwork(buffer)
-            map[key] = value
-        }
-        return map
-    }
-
-    //
-    // me when https://img.lukynka.cloud/wtf.png
-    //
-    override fun readJson(json: JsonElement, field: String): Map<K, V> {
-        val jsonArrayToReadFrom: JsonArray
-
-        if (field.isEmpty() || json is JsonArray) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            jsonArrayToReadFrom = json
-        } else {
-            val jsonObject = json.asObjectOrThrow()
-            if (!jsonObject.has(field)) {
-                throw IllegalArgumentException("Field '$field' does not exist")
-            }
-            val jsonElement = jsonObject.get(field)
-            if (jsonElement !is JsonArray) {
-                throw IllegalArgumentException("Field '$field' is not json array")
-            }
-
-            jsonArrayToReadFrom = jsonElement
-        }
-
-        val map = mutableMapOf<K, V>()
-
-        jsonArrayToReadFrom.forEach { entryElement ->
-            if (!entryElement.isJsonObject) {
-                throw IllegalArgumentException("map entry is not json array")
-            }
-            val entryObj = entryElement.asJsonObject
-            if (!entryObj.has("key") || !entryObj.has("value")) {
-                throw IllegalArgumentException("map entry is missing key or value field")
-            }
-
-            val key = keyCodec.readJson(entryObj, "key")
-            val value = valueCodec.readJson(entryObj, "value")
-            map[key] = value
-        }
-        return map
-    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): Map<K, V> {
-        return transcoder.readMap<K, V>(format, field, keyCodec, valueCodec)
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: Map<K, V>, field: String) {
-        transcoder.writeMap<K, V>(format, field, value, keyCodec, valueCodec)
-    }
-
-    override fun writeJson(json: JsonElement, value: Map<K, V>, field: String) {
-        var jsonArray: JsonArray = JsonArray()
-
-        if (field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            jsonArray = json
-        }
-
-        value.forEach { (key, entryValue) ->
-            val entryObj = JsonObject()
-            keyCodec.writeJson(entryObj, key, "key")
-            valueCodec.writeJson(entryObj, entryValue, "value")
-            jsonArray.add(entryObj)
-        }
-
-        if (json is JsonObject) json.add(field, jsonArray)
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/MutableListCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/MutableListCodec.kt
deleted file mode 100644
index b416b8f..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/MutableListCodec.kt
+++ /dev/null
@@ -1,78 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonArray
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import io.netty.buffer.ByteBuf
-
-class MutableListCodec<T>(val elementCodec: Codec<T>) : Codec<MutableList<T>> {
-
-    override fun readNetwork(buffer: ByteBuf): MutableList<T> {
-        val inner = mutableListOf<T>()
-        val size = Codecs.VarInt.readNetwork(buffer)
-        for (i in 0 until size) {
-            inner.add(elementCodec.readNetwork(buffer))
-        }
-        return inner
-    }
-
-    override fun writeNetwork(buffer: ByteBuf, value: MutableList<T>) {
-        Codecs.VarInt.writeNetwork(buffer, value.size)
-        value.forEach { element ->
-            elementCodec.writeNetwork(buffer, element)
-        }
-    }
-
-    override fun readJson(json: JsonElement, field: String): MutableList<T> {
-        val list = mutableListOf<T>()
-
-        if(field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot read json as root node")
-            json.forEach { element ->
-                list.add(elementCodec.readJson(element))
-            }
-            return list
-        }
-
-        val jsonObject = json.asObjectOrThrow()
-        if (!jsonObject.has(field)) {
-            throw IllegalArgumentException("Field '$field' does not exist in current json: $jsonObject")
-        }
-
-        val element = jsonObject.get(field) ?: throw IllegalArgumentException("Field `$field` does not exist in current json: $jsonObject!")
-        if(!element.isJsonArray) throw IllegalArgumentException("Field `$field` is not json array element! (json: $jsonObject)")
-        val jsonArray = element.asJsonArray!!
-
-        jsonArray.forEach { child ->
-            list.add(elementCodec.readJson(child))
-        }
-
-        return list
-    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): MutableList<T> {
-        return transcoder.readList<T>(format, field, elementCodec).toMutableList()
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: MutableList<T>, field: String) {
-        transcoder.writeList(format, field, value, elementCodec)
-    }
-
-    override fun writeJson(json: JsonElement, value: MutableList<T>, field: String) {
-        var arrayToWriteTo: JsonArray = JsonArray()
-
-        if (field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            arrayToWriteTo = json
-        }
-
-        value.forEach { element ->
-            val tempObj = JsonObject()
-            elementCodec.writeJson(tempObj, element, "value")
-            val elementValue = tempObj.get("value")
-            arrayToWriteTo.add(elementValue)
-        }
-
-        if (json is JsonObject) json.add(field, arrayToWriteTo)
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/MutableMapCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/MutableMapCodec.kt
deleted file mode 100644
index 504f22c..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/MutableMapCodec.kt
+++ /dev/null
@@ -1,91 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonArray
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import io.netty.buffer.ByteBuf
-
-class MutableMapCodec<K, V>(private val keyCodec: Codec<K>, private val valueCodec: Codec<V>) : Codec<MutableMap<K, V>> {
-
-    override fun writeNetwork(buffer: ByteBuf, value: MutableMap<K, V>) {
-        Codecs.VarInt.writeNetwork(buffer, value.size)
-        value.forEach { (key, value) ->
-            keyCodec.writeNetwork(buffer, key)
-            valueCodec.writeNetwork(buffer, value)
-        }
-    }
-
-    override fun readNetwork(buffer: ByteBuf): MutableMap<K, V> {
-        val map = mutableMapOf<K, V>()
-        val size = Codecs.VarInt.readNetwork(buffer)
-        for (i in 0 until size) {
-            val key = keyCodec.readNetwork(buffer)
-            val value = valueCodec.readNetwork(buffer)
-            map[key] = value
-        }
-        return map
-    }
-
-    override fun readJson(json: JsonElement, field: String): MutableMap<K, V> {
-        val jsonArrayToReadFrom: JsonArray
-
-        if (field.isEmpty() || json is JsonArray) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            jsonArrayToReadFrom = json
-        } else {
-            val jsonObject = json.asObjectOrThrow()
-            if (!jsonObject.has(field)) {
-                throw IllegalArgumentException("Field '$field' does not exist")
-            }
-            val jsonElement = jsonObject.get(field)
-            if (jsonElement !is JsonArray) {
-                throw IllegalArgumentException("Field '$field' is not json array")
-            }
-
-            jsonArrayToReadFrom = jsonElement
-        }
-
-        val map = mutableMapOf<K, V>()
-
-        jsonArrayToReadFrom.forEach { entryElement ->
-            if (!entryElement.isJsonObject) {
-                throw IllegalArgumentException("map entry is not json array")
-            }
-            val entryObj = entryElement.asJsonObject
-            if (!entryObj.has("key") || !entryObj.has("value")) {
-                throw IllegalArgumentException("map entry is missing key or value field")
-            }
-
-            val key = keyCodec.readJson(entryObj, "key")
-            val value = valueCodec.readJson(entryObj, "value")
-            map[key] = value
-        }
-        return map
-    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): MutableMap<K, V> {
-        return transcoder.readMap<K, V>(format, field, keyCodec, valueCodec).toMutableMap()
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: MutableMap<K, V>, field: String) {
-        transcoder.writeMap<K, V>(format, field, value, keyCodec, valueCodec)
-    }
-
-    override fun writeJson(json: JsonElement, value: MutableMap<K, V>, field: String) {
-        var jsonArray: JsonArray = JsonArray()
-
-        if (field.isEmpty()) { // root node
-            if (json !is JsonArray) throw IllegalStateException("JsonElement is not JsonArray, cannot write json as root node")
-            jsonArray = json
-        }
-
-        value.forEach { (key, entryValue) ->
-            val entryObj = JsonObject()
-            keyCodec.writeJson(entryObj, key, "key")
-            valueCodec.writeJson(entryObj, entryValue, "value")
-            jsonArray.add(entryObj)
-        }
-
-        if (json is JsonObject) json.add(field, jsonArray)
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/OptionalCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/OptionalCodec.kt
deleted file mode 100644
index 1811cd1..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/OptionalCodec.kt
+++ /dev/null
@@ -1,67 +0,0 @@
-package io.github.dockyardmc.tide
-
-import com.google.gson.JsonElement
-import com.google.gson.JsonNull
-import io.netty.buffer.ByteBuf
-
-class OptionalCodec<T>(val elementCodec: Codec<T>) : Codec<T?> {
-
-    override fun readNetwork(buffer: ByteBuf): T? {
-        val isPresent = buffer.readBoolean()
-        if (!isPresent) return null
-        return elementCodec.readNetwork(buffer)
-    }
-
-    override fun writeNetwork(buffer: ByteBuf, value: T?) {
-        buffer.writeBoolean(value != null)
-        if (value != null) {
-            elementCodec.writeNetwork(buffer, value)
-        }
-    }
-
-    override fun readJson(json: JsonElement, field: String): T? {
-        val jsonElementToRead = if (field.isEmpty()) { // root node
-            json
-        } else {
-            json.asObjectOrThrow().get(field) ?: throw IllegalArgumentException("Field `$field` does not exist in current json: $json")
-        }
-
-        if (jsonElementToRead.isJsonNull) return null
-        return elementCodec.readJson(jsonElementToRead)
-    }
-
-//    override fun readJson(json: JsonElement, field: String): T? {
-//        log("Reading $field in $json", LogType.FATAL)
-//        val jsonElementToRead = if (field.isEmpty()) {
-//            // Handle root element case
-//            if (json.isJsonNull) null else json
-//        } else {
-//            // Handle nested field case
-//            if (!json.isJsonObject) return null
-//            val jsonObject = json.asJsonObject
-//
-//            jsonObject.get(field)?.takeIf { jsonElement -> !jsonElement.isJsonNull }
-//        }
-//
-//        return jsonElementToRead?.let { jsonElement ->
-//            elementCodec.readJson(jsonElement)
-//        }
-//    }
-
-    override fun <A> readTranscoded(transcoder: Transcoder<A>, format: A, field: String): T? {
-        return transcoder.readOptional<T>(format, field, elementCodec)
-    }
-
-    override fun <A> writeTranscoded(transcoder: Transcoder<A>, format: A, value: T?, field: String) {
-        transcoder.writeOptional<T>(format, field, value, elementCodec)
-    }
-
-    override fun writeJson(json: JsonElement, value: T?, field: String) {
-
-        if (value != null) {
-            elementCodec.writeJson(json, value, field)
-        } else {
-            json.asObjectOrThrow().add(field, JsonNull.INSTANCE)
-        }
-    }
-}
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/Transcoder.kt b/src/main/kotlin/io/github/dockyardmc/tide/Transcoder.kt
deleted file mode 100644
index 819e6fe..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/Transcoder.kt
+++ /dev/null
@@ -1,72 +0,0 @@
-package io.github.dockyardmc.tide
-
-import java.util.UUID
-import kotlin.reflect.KClass
-
-//my coder is WHAT? 🏳️‍⚧️🏳️‍⚧️🏳️‍⚧️
-interface Transcoder<T> {
-
-    fun writeInt(format: T, field: String, value: Int)
-
-    fun writeString(format: T, field: String, value: String)
-
-    fun writeBoolean(format: T, field: String, value: Boolean)
-
-    fun writeVarInt(format: T, field: String, value: Int)
-
-    fun writeByteArray(format: T, field: String, value: ByteArray)
-
-    fun writeUUID(format: T, field: String, value: UUID)
-
-    fun writeLong(format: T, field: String, value: Long)
-
-    fun writeFloat(format: T, field: String, value: Float)
-
-    fun writeDouble(format: T, field: String, value: Double)
-
-    fun writeByte(format: T, field: String, value: Byte)
-
-    //-----------------------------------------------------------//
-
-    fun <D> writeOptional(format: T, field: String, value: D?, codec: Codec<D>)
-
-    fun <D> readOptional(format: T, field: String, codec: Codec<D>): D?
-
-
-    fun <D> writeList(format: T, field: String, value: List<D>, codec: Codec<D>)
-
-    fun <D> readList(format: T, field: String, codec: Codec<D>): List<D>
-
-
-    fun <K, V> writeMap(format: T, field: String, value: Map<K, V>, keyCodec: Codec<K>, valueCodec: Codec<V>)
-
-    fun <K, V> readMap(format: T, field: String, keyCodec: Codec<K>, valueCodec: Codec<V>): Map<K, V>
-
-
-    fun <E> writeEnum(kClass: KClass<*>, format: T, field: String, value: E)
-
-    fun <E> readEnum(kClass: KClass<*>, format: T, field: String): E
-
-    //-----------------------------------------------------------//
-
-    fun readInt(format: T, field: String): Int
-
-    fun readString(format: T, field: String): String
-
-    fun readBoolean(format: T, field: String): Boolean
-
-    fun readVarInt(format: T, field: String): Int
-
-    fun readByteArray(format: T, field: String): ByteArray
-
-    fun readUUID(format: T, field: String): UUID
-
-    fun readLong(format: T, field: String): Long
-
-    fun readFloat(format: T, field: String): Float
-
-    fun readDouble(format: T, field: String): Double
-
-    fun readByte(format: T, field: String): Byte
-
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/Codec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/Codec.kt
new file mode 100644
index 0000000..26c192d
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/Codec.kt
@@ -0,0 +1,130 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+import io.github.dockyardmc.tide.types.Either
+import java.util.*
+
+interface Codec<T> {
+    fun <D> encode(transcoder: Transcoder<D>, value: T): D
+    fun <D> decode(transcoder: Transcoder<D>, value: D): T
+
+    fun <S> transform(from: (T) -> S, to: (S) -> T): TransformativeCodec<T, S> {
+        return TransformativeCodec<T, S>(this, from, to)
+    }
+
+    fun list(): Codec<List<T>> {
+        return ListCodec<T>(this)
+    }
+
+    fun <V> mapValue(valueCodec: Codec<V>): Codec<Map<T, V>> {
+        return MapCodec<T, V>(this, valueCodec)
+    }
+
+    fun optional(): Codec<T?> {
+        return OptionalCodec<T>(this)
+    }
+
+    fun default(default: T): Codec<T> {
+        return DefaultCodec<T>(this, default)
+    }
+
+    class EncodingException(override val message: String) : Exception()
+    class DecodingException(override val message: String) : Exception()
+
+    companion object {
+        val BOOLEAN: Codec<Boolean> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeBoolean(value) },
+            { transcoder, value -> transcoder.decodeBoolean(value) }
+        )
+
+        val BYTE: Codec<Byte> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeByte(value) },
+            { transcoder, value -> transcoder.decodeByte(value) }
+        )
+
+        val SHORT: Codec<Short> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeShort(value) },
+            { transcoder, value -> transcoder.decodeShort(value) }
+        )
+
+        val INT: Codec<Int> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeInt(value) },
+            { transcoder, value -> transcoder.decodeInt(value) }
+        )
+
+        val LONG: Codec<Long> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeLong(value) },
+            { transcoder, value -> transcoder.decodeLong(value) }
+        )
+
+        val FLOAT: Codec<Float> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeFloat(value) },
+            { transcoder, value -> transcoder.decodeFloat(value) }
+        )
+
+        val DOUBLE: Codec<Double> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeDouble(value) },
+            { transcoder, value -> transcoder.decodeDouble(value) }
+        )
+
+        val STRING: Codec<String> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeString(value) },
+            { transcoder, value -> transcoder.decodeString(value) }
+        )
+
+        val BYTE_ARRAY: Codec<ByteArray> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeByteArray(value) },
+            { transcoder, value -> transcoder.decodeByteArray(value) }
+        )
+
+        val INT_ARRAY: Codec<IntArray> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeIntArray(value) },
+            { transcoder, value -> transcoder.decodeIntArray(value) }
+        )
+
+        val LONG_ARRAY: Codec<LongArray> = PrimitiveCodec(
+            { transcoder, value -> transcoder.encodeLongArray(value) },
+            { transcoder, value -> transcoder.decodeLongArray(value) }
+        )
+
+        val UUID: Codec<UUID> = INT_ARRAY.transform(CodecUtils::intArrayToUuid, CodecUtils::uuidToIntArray)
+
+        val UUID_STRING: Codec<UUID> = STRING.transform(java.util.UUID::fromString, java.util.UUID::toString)
+
+        inline fun <reified E : Enum<E>> enum(): Codec<E> {
+            return STRING.transform(
+                { value -> E::class.java.enumConstants.first { const -> const.name == value.uppercase() } },
+                { value -> value.name.lowercase() }
+            )
+        }
+
+        fun <L, R> either(leftCodec: Codec<L>, rightCodec: Codec<R>): Codec<Either<L, R>> {
+            return EitherCodec(leftCodec, rightCodec)
+        }
+
+        fun <T> recursive(self: (Codec<T>) -> Codec<T>): RecursiveCodec<T> {
+            return RecursiveCodec<T>(self)
+        }
+
+        fun <T> forwardRef(supplier: () -> Codec<T>): ForwardRefCodec<T> {
+            return ForwardRefCodec<T>(supplier)
+        }
+    }
+
+    private class PrimitiveCodec<T>(
+        private val encoder: (Transcoder<Any?>, T) -> Any?,
+        private val decoder: (Transcoder<Any?>, Any?) -> T
+    ) : Codec<T> {
+
+        @Suppress("UNCHECKED_CAST")
+        override fun <D> encode(transcoder: Transcoder<D>, value: T): D {
+            return encoder.invoke(transcoder as Transcoder<Any?>, value) as D
+        }
+
+
+        @Suppress("UNCHECKED_CAST")
+        override fun <D> decode(transcoder: Transcoder<D>, value: D): T {
+            return decoder.invoke(transcoder as Transcoder<Any?>, value)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/CodecUtils.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/CodecUtils.kt
new file mode 100644
index 0000000..f80e0ad
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/CodecUtils.kt
@@ -0,0 +1,130 @@
+package io.github.dockyardmc.tide.codec
+
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.Unpooled
+import io.netty.handler.codec.DecoderException
+import java.nio.charset.StandardCharsets
+import java.util.*
+
+object CodecUtils {
+
+    const val SEGMENT_BITS: Int = 0x7F
+    const val CONTINUE_BIT: Int = 0x80
+    const val MAXIMUM_VAR_INT_SIZE = 5
+
+    fun uuidToIntArray(uuid: UUID): IntArray {
+        val uuidMost = uuid.mostSignificantBits
+        val uuidLeast = uuid.leastSignificantBits
+        return intArrayOf(
+            (uuidMost shr 32).toInt(),
+            uuidMost.toInt(),
+            (uuidLeast shr 32).toInt(),
+            uuidLeast.toInt()
+        )
+    }
+
+    fun intArrayToUuid(array: IntArray): UUID {
+        val uuidMost = array[0].toLong() shl 32 or (array[1].toLong() and 0xFFFFFFFFL)
+        val uuidLeast = array[2].toLong() shl 32 or (array[3].toLong() and 0xFFFFFFFFL)
+
+        return UUID(uuidMost, uuidLeast)
+    }
+
+    fun readVarInt(buffer: ByteBuf): Int {
+        val readable = buffer.readableBytes()
+        if (readable == 0) throw Codec.DecodingException("Invalid VarInt")
+
+        // decode only one byte first as this is the most common size of varints
+        var current = buffer.readByte().toInt()
+        if (current and CONTINUE_BIT != 128) {
+            return current
+        }
+
+        // no point in while loop that has higher overhead instead of for loop with max size of the varint
+        val maxRead = MAXIMUM_VAR_INT_SIZE.coerceAtMost(readable)
+        var varInt = current and SEGMENT_BITS
+        for (i in 1..<maxRead) {
+            current = buffer.readByte().toInt()
+            varInt = varInt or ((current and SEGMENT_BITS) shl i * 7)
+            if (current and CONTINUE_BIT != 128) {
+                return varInt
+            }
+        }
+        throw Codec.DecodingException("Invalid VarInt")
+    }
+
+    // https://steinborn.me/posts/performance/how-fast-can-you-write-a-varint/
+    // little bit modified to write bytes directly because kotlin fucks up the byte order
+    fun writeVarInt(buffer: ByteBuf, int: Int) {
+        when {
+            // 1-byte
+            int and (-1 shl 7) == 0 -> {
+                buffer.writeByte(int)
+            }
+
+            // 2-byte
+            int and (-1 shl 14) == 0 -> {
+                val w = (int and SEGMENT_BITS or CONTINUE_BIT) shl 8 or (int ushr 7)
+                buffer.writeShort(w)
+            }
+
+            // 3-byte
+            int and (-1 shl 21) == 0 -> {
+                buffer.writeByte(int and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 7) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte(int ushr 14)
+            }
+
+            // 4-byte
+            int and (-1 shl 28) == 0 -> {
+                buffer.writeByte(int and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 7) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 14) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte(int ushr 21)
+            }
+
+            // 5-byte
+            else -> {
+                buffer.writeByte(int and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 7) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 14) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte((int ushr 21) and SEGMENT_BITS or CONTINUE_BIT)
+                buffer.writeByte(int ushr 28)
+            }
+        }
+    }
+
+    fun readString(buffer: ByteBuf, i: Int): String {
+        val maxSize = i * 3
+        val size = readVarInt(buffer)
+        if (size > maxSize) throw DecoderException("The received string was longer than the allowed $maxSize ($size > $maxSize)")
+        if (size < 0) throw DecoderException("The received string's length was smaller than 0")
+        val string = buffer.toString(buffer.readerIndex(), size, StandardCharsets.UTF_8)
+        buffer.readerIndex(buffer.readerIndex() + size)
+        if (string.length > i) throw DecoderException("The received string was longer than the allowed (${string.length} > $i)")
+        return string
+    }
+
+    fun readString(buffer: ByteBuf) = this.readString(buffer, Short.MAX_VALUE.toInt())
+
+    fun writeString(buffer: ByteBuf, text: String): ByteBuf {
+        val utf8Bytes = text.toByteArray(StandardCharsets.UTF_8)
+        val length = utf8Bytes.size
+        writeVarInt(buffer, length)
+        buffer.writeBytes(utf8Bytes)
+        return buffer
+    }
+}
+
+fun ByteBuf.toByteArraySafe(): ByteArray {
+    if (this.hasArray()) {
+        return this.array()
+    }
+
+    val bytes = ByteArray(this.readableBytes())
+    this.getBytes(this.readerIndex(), bytes)
+
+    return bytes
+}
+
+fun ByteArray.toByteBuf(): ByteBuf = Unpooled.copiedBuffer(this)
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/DefaultCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/DefaultCodec.kt
new file mode 100644
index 0000000..32b2cb1
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/DefaultCodec.kt
@@ -0,0 +1,18 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class DefaultCodec<T>(val inner: Codec<T>, val default: T) : Codec<T> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: T): D {
+        return inner.encode(transcoder, value ?: default)
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): T {
+        val result = runCatching {
+            inner.decode(transcoder, value)
+        }
+        if (result.isSuccess) return result.getOrThrow()
+        return default
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/EitherCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/EitherCodec.kt
new file mode 100644
index 0000000..9b03d45
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/EitherCodec.kt
@@ -0,0 +1,25 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+import io.github.dockyardmc.tide.types.Either
+
+class EitherCodec<L, R>(val leftCodec: Codec<L>, val rightCodec: Codec<R>) : Codec<Either<L, R>> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: Either<L, R>): D {
+        return when (value) {
+            is Either.Left -> leftCodec.encode(transcoder, value.value)
+            is Either.Right -> rightCodec.encode(transcoder, value.value)
+        }
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): Either<L, R> {
+        val result = runCatching {
+            leftCodec.decode(transcoder, value)
+        }
+        return if (result.isSuccess) {
+            Either.left(result.getOrThrow())
+        } else {
+            Either.right(rightCodec.decode(transcoder, value))
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/ForwardRefCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/ForwardRefCodec.kt
new file mode 100644
index 0000000..01a7033
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/ForwardRefCodec.kt
@@ -0,0 +1,16 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class ForwardRefCodec<T>(delegateFunc: () -> Codec<T>) : Codec<T> {
+    private val delegate = delegateFunc.invoke()
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: T): D {
+        return delegate.encode(transcoder, value)
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): T {
+        return delegate.decode(transcoder, value)
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/ListCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/ListCodec.kt
new file mode 100644
index 0000000..358c605
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/ListCodec.kt
@@ -0,0 +1,23 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class ListCodec<T>(val inner: Codec<T>) : Codec<List<T>> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: List<T>): D {
+        val encodedList = transcoder.encodeList(value.size)
+        value.forEach { item ->
+            encodedList.add(inner.encode(transcoder, item))
+        }
+        return encodedList.build()
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): List<T> {
+        val listResult = transcoder.decodeList(value)
+        val decodedList = mutableListOf<T>()
+        listResult.forEach { item ->
+            decodedList.add(inner.decode(transcoder, item))
+        }
+        return decodedList
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/MapCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/MapCodec.kt
new file mode 100644
index 0000000..c62ce5d
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/MapCodec.kt
@@ -0,0 +1,31 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class MapCodec<K, V>(val keyCodec: Codec<K>, val valueCodec: Codec<V>) : Codec<Map<K, V>> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: Map<K, V>): D {
+        val mapBuilder = transcoder.encodeMap()
+        value.forEach { entry ->
+            val keyResult = keyCodec.encode(transcoder, entry.key)
+            val valueResult = valueCodec.encode(transcoder, entry.value)
+
+            mapBuilder.put(keyResult, valueResult)
+        }
+
+        return mapBuilder.build()
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): Map<K, V> {
+        val mapResult = transcoder.decodeMap(value)
+        val decodedMap = mutableMapOf<K, V>()
+
+        mapResult.getKeys().forEach { key ->
+            val keyResult = keyCodec.decode(transcoder, transcoder.encodeString(key))
+            val valueResult = valueCodec.decode(transcoder, mapResult.getValue(key))
+            decodedMap[keyResult] = valueResult
+        }
+
+        return decodedMap
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/OptionalCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/OptionalCodec.kt
new file mode 100644
index 0000000..9b60c18
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/OptionalCodec.kt
@@ -0,0 +1,19 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class OptionalCodec<T>(val inner: Codec<T>) : Codec<T?> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: T?): D {
+        if (value == null) return transcoder.encodeNull()
+        return inner.encode(transcoder, value)
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): T? {
+        val result = runCatching {
+            inner.decode(transcoder, value)
+        }
+        if (result.isSuccess) return result.getOrThrow()
+        return null
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/RecursiveCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/RecursiveCodec.kt
new file mode 100644
index 0000000..e23cf5b
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/RecursiveCodec.kt
@@ -0,0 +1,17 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+class RecursiveCodec<T>(self: (Codec<T>) -> Codec<T>) : Codec<T> {
+
+    val delegate = self.invoke(this)
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: T): D {
+        return delegate.encode(transcoder, value)
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): T {
+        return delegate.decode(transcoder, value)
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/StructCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/StructCodec.kt
new file mode 100644
index 0000000..824f083
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/StructCodec.kt
@@ -0,0 +1,999 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+interface StructCodec<R> : Codec<R> {
+
+    fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T
+
+    fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R
+
+    override fun <T> encode(transcoder: Transcoder<T>, value: R): T {
+        return encodeToMap<T>(transcoder, value, transcoder.encodeMap())
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): R {
+        return decodeFromMap(transcoder, transcoder.decodeMap(value))
+    }
+
+    companion object {
+        const val INLINE = "_inline_"
+
+        fun <R> of(new: () -> R): StructCodec<R> {
+            return object : StructCodec<R> {
+
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    return transcoder.emptyMap()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    return new.invoke()
+                }
+
+            }
+        }
+
+        fun <P1, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            new: (P1) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    return new.invoke(result1)
+                }
+
+            }
+        }
+
+        fun <P1, P2, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            new: (P1, P2) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    return new.invoke(result1, result2)
+                }
+
+            }
+        }
+
+        fun <P1, P2, P3, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            new: (P1, P2, P3) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    return new.invoke(result1, result2, result3)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            new: (P1, P2, P3, P4) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    return new.invoke(result1, result2, result3, result4)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            new: (P1, P2, P3, P4, P5) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    return new.invoke(result1, result2, result3, result4, result5)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            new: (P1, P2, P3, P4, P5, P6) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            new: (P1, P2, P3, P4, P5, P6, P7) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    put(transcoder, codec16, map, name16, getter16.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    val result16 = get(transcoder, codec16, name16, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
+            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    put(transcoder, codec16, map, name16, getter16.invoke(value))
+                    put(transcoder, codec17, map, name17, getter17.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    val result16 = get(transcoder, codec16, name16, map)
+                    val result17 = get(transcoder, codec17, name17, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
+            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
+            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    put(transcoder, codec16, map, name16, getter16.invoke(value))
+                    put(transcoder, codec17, map, name17, getter17.invoke(value))
+                    put(transcoder, codec18, map, name18, getter18.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    val result16 = get(transcoder, codec16, name16, map)
+                    val result17 = get(transcoder, codec17, name17, map)
+                    val result18 = get(transcoder, codec18, name18, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
+            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
+            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
+            name19: String, codec19: Codec<P19>, getter19: (R) -> P19,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    put(transcoder, codec16, map, name16, getter16.invoke(value))
+                    put(transcoder, codec17, map, name17, getter17.invoke(value))
+                    put(transcoder, codec18, map, name18, getter18.invoke(value))
+                    put(transcoder, codec19, map, name19, getter19.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    val result16 = get(transcoder, codec16, name16, map)
+                    val result17 = get(transcoder, codec17, name17, map)
+                    val result18 = get(transcoder, codec18, name18, map)
+                    val result19 = get(transcoder, codec19, name19, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18, result19)
+                }
+            }
+        }
+
+        fun <P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R> of(
+            name1: String, codec1: Codec<P1>, getter1: (R) -> P1,
+            name2: String, codec2: Codec<P2>, getter2: (R) -> P2,
+            name3: String, codec3: Codec<P3>, getter3: (R) -> P3,
+            name4: String, codec4: Codec<P4>, getter4: (R) -> P4,
+            name5: String, codec5: Codec<P5>, getter5: (R) -> P5,
+            name6: String, codec6: Codec<P6>, getter6: (R) -> P6,
+            name7: String, codec7: Codec<P7>, getter7: (R) -> P7,
+            name8: String, codec8: Codec<P8>, getter8: (R) -> P8,
+            name9: String, codec9: Codec<P9>, getter9: (R) -> P9,
+            name10: String, codec10: Codec<P10>, getter10: (R) -> P10,
+            name11: String, codec11: Codec<P11>, getter11: (R) -> P11,
+            name12: String, codec12: Codec<P12>, getter12: (R) -> P12,
+            name13: String, codec13: Codec<P13>, getter13: (R) -> P13,
+            name14: String, codec14: Codec<P14>, getter14: (R) -> P14,
+            name15: String, codec15: Codec<P15>, getter15: (R) -> P15,
+            name16: String, codec16: Codec<P16>, getter16: (R) -> P16,
+            name17: String, codec17: Codec<P17>, getter17: (R) -> P17,
+            name18: String, codec18: Codec<P18>, getter18: (R) -> P18,
+            name19: String, codec19: Codec<P19>, getter19: (R) -> P19,
+            name20: String, codec20: Codec<P20>, getter20: (R) -> P20,
+            new: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R
+        ): StructCodec<R> {
+            return object : StructCodec<R> {
+                override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+                    put(transcoder, codec1, map, name1, getter1.invoke(value))
+                    put(transcoder, codec2, map, name2, getter2.invoke(value))
+                    put(transcoder, codec3, map, name3, getter3.invoke(value))
+                    put(transcoder, codec4, map, name4, getter4.invoke(value))
+                    put(transcoder, codec5, map, name5, getter5.invoke(value))
+                    put(transcoder, codec6, map, name6, getter6.invoke(value))
+                    put(transcoder, codec7, map, name7, getter7.invoke(value))
+                    put(transcoder, codec8, map, name8, getter8.invoke(value))
+                    put(transcoder, codec9, map, name9, getter9.invoke(value))
+                    put(transcoder, codec10, map, name10, getter10.invoke(value))
+                    put(transcoder, codec11, map, name11, getter11.invoke(value))
+                    put(transcoder, codec12, map, name12, getter12.invoke(value))
+                    put(transcoder, codec13, map, name13, getter13.invoke(value))
+                    put(transcoder, codec14, map, name14, getter14.invoke(value))
+                    put(transcoder, codec15, map, name15, getter15.invoke(value))
+                    put(transcoder, codec16, map, name16, getter16.invoke(value))
+                    put(transcoder, codec17, map, name17, getter17.invoke(value))
+                    put(transcoder, codec18, map, name18, getter18.invoke(value))
+                    put(transcoder, codec19, map, name19, getter19.invoke(value))
+                    put(transcoder, codec20, map, name20, getter20.invoke(value))
+                    return map.build()
+                }
+
+                override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+                    val result1 = get(transcoder, codec1, name1, map)
+                    val result2 = get(transcoder, codec2, name2, map)
+                    val result3 = get(transcoder, codec3, name3, map)
+                    val result4 = get(transcoder, codec4, name4, map)
+                    val result5 = get(transcoder, codec5, name5, map)
+                    val result6 = get(transcoder, codec6, name6, map)
+                    val result7 = get(transcoder, codec7, name7, map)
+                    val result8 = get(transcoder, codec8, name8, map)
+                    val result9 = get(transcoder, codec9, name9, map)
+                    val result10 = get(transcoder, codec10, name10, map)
+                    val result11 = get(transcoder, codec11, name11, map)
+                    val result12 = get(transcoder, codec12, name12, map)
+                    val result13 = get(transcoder, codec13, name13, map)
+                    val result14 = get(transcoder, codec14, name14, map)
+                    val result15 = get(transcoder, codec15, name15, map)
+                    val result16 = get(transcoder, codec16, name16, map)
+                    val result17 = get(transcoder, codec17, name17, map)
+                    val result18 = get(transcoder, codec18, name18, map)
+                    val result19 = get(transcoder, codec19, name19, map)
+                    val result20 = get(transcoder, codec20, name20, map)
+                    return new.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18, result19, result20)
+                }
+            }
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        private fun <D, T> put(transcoder: Transcoder<D>, codec: Codec<T>, map: Transcoder.VirtualMapBuilder<D>, key: String, value: T): D {
+
+            if (key == INLINE) {
+                val encodeCodec: Codec<T> = if (codec is OptionalCodec<*>) codec.inner as Codec<T> else if (codec is DefaultCodec<T>) codec.inner else codec
+                if (encodeCodec !is StructCodec<T>) {
+                    throw Codec.EncodingException("provided codec for $key is not StructCodec")
+                }
+
+                return encodeCodec.encodeToMap(transcoder, value, map)
+            }
+
+            val result = codec.encode(transcoder, value)
+            map.put(key, result)
+            return result
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        private fun <D, T> get(transcoder: Transcoder<D>, codec: Codec<T>, key: String, map: Transcoder.VirtualMap<D>): T {
+
+            if (key == INLINE) {
+                val decodeCodec = if (codec is OptionalCodec<*>) codec.inner else if (codec is DefaultCodec<*>) codec.inner else codec
+                if (decodeCodec !is StructCodec<*>) {
+                    throw Codec.DecodingException("provided codec for $key is not StructCodec")
+                }
+
+                val result = runCatching {
+                    decodeCodec.decodeFromMap(transcoder, map)
+                }
+                if (result.isFailure && codec is DefaultCodec<*>) {
+                    return codec.default as T
+                }
+                if (result.isFailure && codec is OptionalCodec<*>) {
+                    return null as T
+                }
+                return result.getOrThrow() as T
+            }
+
+            if (codec is DefaultCodec<*> && !map.hasValue(key)) {
+                return codec.default as T
+            }
+
+            if (codec is OptionalCodec<*> && !map.hasValue(key)) {
+                return null as T
+            }
+
+            return codec.decode(transcoder, map.getValue(key))
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/codec/TransformativeCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/codec/TransformativeCodec.kt
new file mode 100644
index 0000000..e5e58e4
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/codec/TransformativeCodec.kt
@@ -0,0 +1,16 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+data class TransformativeCodec<T, S>(val inner: Codec<T>, val to: (T) -> S, val from: (S) -> T) : Codec<S> {
+
+    override fun <D> encode(transcoder: Transcoder<D>, value: S): D {
+        return inner.encode(transcoder, from.invoke(value))
+    }
+
+    override fun <D> decode(transcoder: Transcoder<D>, value: D): S {
+        val innerValue = inner.decode(transcoder, value)
+        return to.invoke(innerValue)
+    }
+
+}
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/DefaultStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/DefaultStreamCodec.kt
new file mode 100644
index 0000000..3223a2f
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/DefaultStreamCodec.kt
@@ -0,0 +1,18 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+class DefaultStreamCodec<T>(val inner: StreamCodec<T>, val default: T) : StreamCodec<T> {
+
+    override fun write(buffer: ByteBuf, value: T) {
+        StreamCodec.BOOLEAN.write(buffer, true)
+        val valueToWrite = value ?: default
+        inner.write(buffer, valueToWrite)
+    }
+
+    override fun read(buffer: ByteBuf): T {
+        val isNull = StreamCodec.BOOLEAN.read(buffer)
+        return if (!isNull) inner.read(buffer) else default
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/EitherStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/EitherStreamCodec.kt
new file mode 100644
index 0000000..5cbb43b
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/EitherStreamCodec.kt
@@ -0,0 +1,27 @@
+package io.github.dockyardmc.tide.stream
+
+import io.github.dockyardmc.tide.types.Either
+import io.netty.buffer.ByteBuf
+
+class EitherStreamCodec<L, R>(val leftCodec: StreamCodec<L>, val rightCodec: StreamCodec<R>) : StreamCodec<Either<L, R>> {
+
+    override fun write(buffer: ByteBuf, value: Either<L, R>) {
+
+        when (value) {
+            is Either.Left -> {
+                StreamCodec.BOOLEAN.write(buffer, true)
+                leftCodec.write(buffer, value.value)
+            }
+
+            is Either.Right -> {
+                StreamCodec.BOOLEAN.write(buffer, false)
+                rightCodec.write(buffer, value.value)
+            }
+        }
+    }
+
+    override fun read(buffer: ByteBuf): Either<L, R> {
+        return if (StreamCodec.BOOLEAN.read(buffer)) Either.left(leftCodec.read(buffer)) else Either.right(rightCodec.read(buffer))
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/EnumStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/EnumStreamCodec.kt
new file mode 100644
index 0000000..8afdd9c
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/EnumStreamCodec.kt
@@ -0,0 +1,16 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+import kotlin.reflect.KClass
+
+class EnumStreamCodec<E : Enum<E>>(val kClass: KClass<E>) : StreamCodec<E> {
+
+    override fun write(buffer: ByteBuf, value: E) {
+        StreamCodec.VAR_INT.write(buffer, value.ordinal)
+    }
+
+    override fun read(buffer: ByteBuf): E {
+        return kClass.java.enumConstants[StreamCodec.VAR_INT.read(buffer)]
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/FixedBitSetStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/FixedBitSetStreamCodec.kt
new file mode 100644
index 0000000..380678a
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/FixedBitSetStreamCodec.kt
@@ -0,0 +1,22 @@
+package io.github.dockyardmc.tide.stream
+
+import io.github.dockyardmc.tide.codec.Codec
+import io.github.dockyardmc.tide.codec.toByteArraySafe
+import io.github.dockyardmc.tide.codec.toByteBuf
+import io.netty.buffer.ByteBuf
+import java.util.*
+
+class FixedBitSetStreamCodec(val length: Int) : StreamCodec<BitSet> {
+
+    override fun write(buffer: ByteBuf, value: BitSet) {
+        val setLength = value.length()
+        if (setLength > length) throw Codec.EncodingException("BitSet is larger than expected size ($setLength > $length)")
+        StreamCodec.RAW_BYTES.write(buffer, value.toByteArray().toByteBuf())
+    }
+
+    override fun read(buffer: ByteBuf): BitSet {
+        val array = buffer.readBytes((length + 7) / 8)
+        return BitSet.valueOf(array.toByteArraySafe())
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/LengthPrefixedStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/LengthPrefixedStreamCodec.kt
new file mode 100644
index 0000000..bf7c047
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/LengthPrefixedStreamCodec.kt
@@ -0,0 +1,19 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+import io.netty.buffer.Unpooled
+
+class LengthPrefixedStreamCodec<T>(val inner: StreamCodec<T>) : StreamCodec<T> {
+
+    override fun write(buffer: ByteBuf, value: T) {
+        val innerBuffer = Unpooled.buffer()
+        inner.write(innerBuffer, value)
+        StreamCodec.BYTE_ARRAY.write(buffer, innerBuffer)
+    }
+
+    override fun read(buffer: ByteBuf): T {
+        val innerBuffer = StreamCodec.BYTE_ARRAY.read(buffer)
+        return inner.read(innerBuffer)
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/ListStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/ListStreamCodec.kt
new file mode 100644
index 0000000..5b8ea07
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/ListStreamCodec.kt
@@ -0,0 +1,22 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+class ListStreamCodec<T>(val inner: StreamCodec<T>) : StreamCodec<List<T>> {
+
+    override fun write(buffer: ByteBuf, value: List<T>) {
+        StreamCodec.VAR_INT.write(buffer, value.size)
+        value.forEach { item ->
+            inner.write(buffer, item)
+        }
+    }
+
+    override fun read(buffer: ByteBuf): List<T> {
+        val size = StreamCodec.VAR_INT.read(buffer)
+        val list = mutableListOf<T>()
+        for (i in 0 until size) {
+            list.add(inner.read(buffer))
+        }
+        return list
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/MapStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/MapStreamCodec.kt
new file mode 100644
index 0000000..c6059fd
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/MapStreamCodec.kt
@@ -0,0 +1,27 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+class MapStreamCodec<K, V>(val keyCodec: StreamCodec<K>, val valueCodec: StreamCodec<V>) : StreamCodec<Map<K, V>> {
+
+    override fun write(buffer: ByteBuf, value: Map<K, V>) {
+        StreamCodec.VAR_INT.write(buffer, value.size)
+        value.forEach { (key, value) ->
+            keyCodec.write(buffer, key)
+            valueCodec.write(buffer, value)
+        }
+    }
+
+    override fun read(buffer: ByteBuf): Map<K, V> {
+        val size = StreamCodec.VAR_INT.read(buffer)
+        val map = mutableMapOf<K, V>()
+        for (i in 0 until size) {
+            val key = keyCodec.read(buffer)
+            val value = valueCodec.read(buffer)
+            map[key] = value
+        }
+
+        return map
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/OptionalStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/OptionalStreamCodec.kt
new file mode 100644
index 0000000..94f5146
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/OptionalStreamCodec.kt
@@ -0,0 +1,17 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+class OptionalStreamCodec<T>(val inner: StreamCodec<T>) : StreamCodec<T?> {
+
+    override fun write(buffer: ByteBuf, value: T?) {
+        StreamCodec.BOOLEAN.write(buffer, value != null)
+        if (value != null) inner.write(buffer, value)
+    }
+
+    override fun read(buffer: ByteBuf): T? {
+        val isPresent = StreamCodec.BOOLEAN.read(buffer)
+        return if (isPresent) inner.read(buffer) else null
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/StreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/StreamCodec.kt
new file mode 100644
index 0000000..40f8b07
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/StreamCodec.kt
@@ -0,0 +1,1101 @@
+package io.github.dockyardmc.tide.stream
+
+import io.github.dockyardmc.tide.codec.CodecUtils
+import io.netty.buffer.ByteBuf
+import java.util.*
+
+interface StreamCodec<T> {
+    fun write(buffer: ByteBuf, value: T)
+    fun read(buffer: ByteBuf): T
+
+    fun optional(): OptionalStreamCodec<T> {
+        return OptionalStreamCodec<T>(this)
+    }
+
+    fun default(default: T): DefaultStreamCodec<T> {
+        return DefaultStreamCodec<T>(this, default)
+    }
+
+    fun <S> transform(from: (S) -> T, to: (T) -> S): TransformativeStreamCodec<T, S> {
+        return TransformativeStreamCodec<T, S>(this, to, from)
+    }
+
+    fun <V> mapTo(valueCodec: StreamCodec<V>): MapStreamCodec<T, V> {
+        return MapStreamCodec<T, V>(this, valueCodec)
+    }
+
+    fun list(): ListStreamCodec<T> {
+        return ListStreamCodec<T>(this)
+    }
+
+    companion object {
+        val UNIT = object : StreamCodec<Unit> {
+
+            override fun write(buffer: ByteBuf, value: Unit) {}
+
+            override fun read(buffer: ByteBuf) {}
+        }
+
+        val BOOLEAN = object : StreamCodec<Boolean> {
+
+            override fun write(buffer: ByteBuf, value: Boolean) {
+                buffer.writeBoolean(value)
+            }
+
+            override fun read(buffer: ByteBuf): Boolean {
+                return buffer.readBoolean()
+            }
+        }
+
+        val BYTE = object : StreamCodec<Byte> {
+
+            override fun write(buffer: ByteBuf, value: Byte) {
+                buffer.writeByte(value.toInt())
+            }
+
+            override fun read(buffer: ByteBuf): Byte {
+                return buffer.readByte()
+            }
+        }
+
+        val SHORT = object : StreamCodec<Short> {
+
+            override fun write(buffer: ByteBuf, value: Short) {
+                buffer.writeShort(value.toInt())
+            }
+
+            override fun read(buffer: ByteBuf): Short {
+                return buffer.readShort()
+            }
+        }
+
+        val INT = object : StreamCodec<Int> {
+
+            override fun write(buffer: ByteBuf, value: Int) {
+                buffer.writeInt(value)
+            }
+
+            override fun read(buffer: ByteBuf): Int {
+                return buffer.readInt()
+            }
+        }
+
+        val VAR_INT = object : StreamCodec<Int> {
+
+            override fun write(buffer: ByteBuf, value: Int) {
+                CodecUtils.writeVarInt(buffer, value)
+            }
+
+            override fun read(buffer: ByteBuf): Int {
+                return CodecUtils.readVarInt(buffer)
+            }
+        }
+
+        val LONG = object : StreamCodec<Long> {
+
+            override fun write(buffer: ByteBuf, value: Long) {
+                buffer.writeLong(value)
+            }
+
+            override fun read(buffer: ByteBuf): Long {
+                return buffer.readLong()
+            }
+        }
+
+        val FLOAT = object : StreamCodec<Float> {
+
+            override fun write(buffer: ByteBuf, value: Float) {
+                buffer.writeFloat(value)
+            }
+
+            override fun read(buffer: ByteBuf): Float {
+                return buffer.readFloat()
+            }
+        }
+
+        val DOUBLE = object : StreamCodec<Double> {
+
+            override fun write(buffer: ByteBuf, value: Double) {
+                buffer.writeDouble(value)
+            }
+
+            override fun read(buffer: ByteBuf): Double {
+                return buffer.readDouble()
+            }
+
+        }
+
+        val STRING = object : StreamCodec<String> {
+
+            override fun write(buffer: ByteBuf, value: String) {
+                CodecUtils.writeString(buffer, value)
+            }
+
+            override fun read(buffer: ByteBuf): String {
+                return CodecUtils.readString(buffer)
+            }
+
+        }
+
+        val RAW_BYTES = object : StreamCodec<ByteBuf> {
+
+            override fun write(buffer: ByteBuf, value: ByteBuf) {
+                buffer.writeBytes(value)
+            }
+
+            override fun read(buffer: ByteBuf): ByteBuf {
+                return buffer.readBytes(buffer.readableBytes())
+            }
+        }
+
+        val BYTE_ARRAY = object : StreamCodec<ByteBuf> {
+
+            override fun write(buffer: ByteBuf, value: ByteBuf) {
+                VAR_INT.write(buffer, value.readableBytes())
+                RAW_BYTES.write(buffer, value)
+            }
+
+            override fun read(buffer: ByteBuf): ByteBuf {
+                val size = VAR_INT.read(buffer)
+                return buffer.readBytes(size)
+            }
+        }
+
+        val UUID = object : StreamCodec<UUID> {
+
+            override fun write(buffer: ByteBuf, value: UUID) {
+                LONG.write(buffer, value.mostSignificantBits)
+                LONG.write(buffer, value.leastSignificantBits)
+            }
+
+            override fun read(buffer: ByteBuf): UUID {
+                val mostSignificant = LONG.read(buffer)
+                val leastSignificant = LONG.read(buffer)
+                return UUID(mostSignificant, leastSignificant)
+            }
+        }
+
+        val UUID_STRING = STRING.transform<UUID>({ uuid -> uuid.toString() }, { string -> java.util.UUID.fromString(string) })
+
+        inline fun <reified E : Enum<E>> enum(): StreamCodec<E> {
+            return EnumStreamCodec<E>(E::class)
+        }
+
+        inline fun <reified E : Enum<E>> enumString(): StreamCodec<E> {
+            return STRING.transform<E>({ enum -> enum.name.lowercase() }, { string -> enumValueOf<E>(string) })
+        }
+
+        fun fixedBitSet(length: Int): FixedBitSetStreamCodec {
+            return FixedBitSetStreamCodec(length)
+        }
+
+        fun <T> lengthPrefixed(codec: StreamCodec<T>): StreamCodec<T> {
+            return LengthPrefixedStreamCodec<T>(codec)
+        }
+
+        fun <L, R> either(leftCodec: StreamCodec<L>, rightCodec: StreamCodec<R>): EitherStreamCodec<L, R> {
+            return EitherStreamCodec<L, R>(leftCodec, rightCodec)
+        }
+
+        fun <R> of(supplier: () -> R): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {}
+
+                override fun read(buffer: ByteBuf): R {
+                    return supplier.invoke()
+                }
+            }
+        }
+
+        fun <R, P1> of(
+            codec1: StreamCodec<P1>,
+            getter1: (R) -> P1,
+            supplier: (P1) -> R
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    return supplier.invoke(result1)
+                }
+            }
+        }
+
+        fun <R, P1, P2> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            supplier: (P1, P2) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    return supplier.invoke(result1, result2)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            supplier: (P1, P2, P3) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    return supplier.invoke(result1, result2, result3)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            supplier: (P1, P2, P3, P4) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            supplier: (P1, P2, P3, P4, P5) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            supplier: (P1, P2, P3, P4, P5, P6) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            supplier: (P1, P2, P3, P4, P5, P6, P7) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            codec16: StreamCodec<P16>, getter16: (R) -> P16,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                    codec16.write(buffer, getter16.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    val result16 = codec16.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            codec16: StreamCodec<P16>, getter16: (R) -> P16,
+            codec17: StreamCodec<P17>, getter17: (R) -> P17,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                    codec16.write(buffer, getter16.invoke(value))
+                    codec17.write(buffer, getter17.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    val result16 = codec16.read(buffer)
+                    val result17 = codec17.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            codec16: StreamCodec<P16>, getter16: (R) -> P16,
+            codec17: StreamCodec<P17>, getter17: (R) -> P17,
+            codec18: StreamCodec<P18>, getter18: (R) -> P18,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                    codec16.write(buffer, getter16.invoke(value))
+                    codec17.write(buffer, getter17.invoke(value))
+                    codec18.write(buffer, getter18.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    val result16 = codec16.read(buffer)
+                    val result17 = codec17.read(buffer)
+                    val result18 = codec18.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            codec16: StreamCodec<P16>, getter16: (R) -> P16,
+            codec17: StreamCodec<P17>, getter17: (R) -> P17,
+            codec18: StreamCodec<P18>, getter18: (R) -> P18,
+            codec19: StreamCodec<P19>, getter19: (R) -> P19,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                    codec16.write(buffer, getter16.invoke(value))
+                    codec17.write(buffer, getter17.invoke(value))
+                    codec18.write(buffer, getter18.invoke(value))
+                    codec19.write(buffer, getter19.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    val result16 = codec16.read(buffer)
+                    val result17 = codec17.read(buffer)
+                    val result18 = codec18.read(buffer)
+                    val result19 = codec19.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18, result19)
+                }
+            }
+        }
+
+        fun <R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> of(
+            codec1: StreamCodec<P1>, getter1: (R) -> P1,
+            codec2: StreamCodec<P2>, getter2: (R) -> P2,
+            codec3: StreamCodec<P3>, getter3: (R) -> P3,
+            codec4: StreamCodec<P4>, getter4: (R) -> P4,
+            codec5: StreamCodec<P5>, getter5: (R) -> P5,
+            codec6: StreamCodec<P6>, getter6: (R) -> P6,
+            codec7: StreamCodec<P7>, getter7: (R) -> P7,
+            codec8: StreamCodec<P8>, getter8: (R) -> P8,
+            codec9: StreamCodec<P9>, getter9: (R) -> P9,
+            codec10: StreamCodec<P10>, getter10: (R) -> P10,
+            codec11: StreamCodec<P11>, getter11: (R) -> P11,
+            codec12: StreamCodec<P12>, getter12: (R) -> P12,
+            codec13: StreamCodec<P13>, getter13: (R) -> P13,
+            codec14: StreamCodec<P14>, getter14: (R) -> P14,
+            codec15: StreamCodec<P15>, getter15: (R) -> P15,
+            codec16: StreamCodec<P16>, getter16: (R) -> P16,
+            codec17: StreamCodec<P17>, getter17: (R) -> P17,
+            codec18: StreamCodec<P18>, getter18: (R) -> P18,
+            codec19: StreamCodec<P19>, getter19: (R) -> P19,
+            codec20: StreamCodec<P20>, getter20: (R) -> P20,
+            supplier: (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20) -> R,
+        ): StreamCodec<R> {
+            return object : StreamCodec<R> {
+                override fun write(buffer: ByteBuf, value: R) {
+                    codec1.write(buffer, getter1.invoke(value))
+                    codec2.write(buffer, getter2.invoke(value))
+                    codec3.write(buffer, getter3.invoke(value))
+                    codec4.write(buffer, getter4.invoke(value))
+                    codec5.write(buffer, getter5.invoke(value))
+                    codec6.write(buffer, getter6.invoke(value))
+                    codec7.write(buffer, getter7.invoke(value))
+                    codec8.write(buffer, getter8.invoke(value))
+                    codec9.write(buffer, getter9.invoke(value))
+                    codec10.write(buffer, getter10.invoke(value))
+                    codec11.write(buffer, getter11.invoke(value))
+                    codec12.write(buffer, getter12.invoke(value))
+                    codec13.write(buffer, getter13.invoke(value))
+                    codec14.write(buffer, getter14.invoke(value))
+                    codec15.write(buffer, getter15.invoke(value))
+                    codec16.write(buffer, getter16.invoke(value))
+                    codec17.write(buffer, getter17.invoke(value))
+                    codec18.write(buffer, getter18.invoke(value))
+                    codec19.write(buffer, getter19.invoke(value))
+                    codec20.write(buffer, getter20.invoke(value))
+                }
+
+                override fun read(buffer: ByteBuf): R {
+                    val result1 = codec1.read(buffer)
+                    val result2 = codec2.read(buffer)
+                    val result3 = codec3.read(buffer)
+                    val result4 = codec4.read(buffer)
+                    val result5 = codec5.read(buffer)
+                    val result6 = codec6.read(buffer)
+                    val result7 = codec7.read(buffer)
+                    val result8 = codec8.read(buffer)
+                    val result9 = codec9.read(buffer)
+                    val result10 = codec10.read(buffer)
+                    val result11 = codec11.read(buffer)
+                    val result12 = codec12.read(buffer)
+                    val result13 = codec13.read(buffer)
+                    val result14 = codec14.read(buffer)
+                    val result15 = codec15.read(buffer)
+                    val result16 = codec16.read(buffer)
+                    val result17 = codec17.read(buffer)
+                    val result18 = codec18.read(buffer)
+                    val result19 = codec19.read(buffer)
+                    val result20 = codec20.read(buffer)
+                    return supplier.invoke(result1, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11, result12, result13, result14, result15, result16, result17, result18, result19, result20)
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/stream/TransformativeStreamCodec.kt b/src/main/kotlin/io/github/dockyardmc/tide/stream/TransformativeStreamCodec.kt
new file mode 100644
index 0000000..37553ca
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/stream/TransformativeStreamCodec.kt
@@ -0,0 +1,15 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+class TransformativeStreamCodec<T, S>(val inner: StreamCodec<T>, val to: (T) -> S, val from: (S) -> T) : StreamCodec<S> {
+
+    override fun write(buffer: ByteBuf, value: S) {
+        inner.write(buffer, from.invoke(value))
+    }
+
+    override fun read(buffer: ByteBuf): S {
+        val innerValue = inner.read(buffer)
+        return to.invoke(innerValue)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/transcoder/JsonTranscoder.kt b/src/main/kotlin/io/github/dockyardmc/tide/transcoder/JsonTranscoder.kt
new file mode 100644
index 0000000..9d15376
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/transcoder/JsonTranscoder.kt
@@ -0,0 +1,133 @@
+package io.github.dockyardmc.tide.transcoder
+
+import com.google.gson.*
+
+object JsonTranscoder : Transcoder<JsonElement> {
+
+    override fun encodeNull(): JsonElement {
+        return JsonNull.INSTANCE
+    }
+
+    override fun encodeBoolean(value: Boolean): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeByte(value: Byte): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeShort(value: Short): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeInt(value: Int): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeLong(value: Long): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeFloat(value: Float): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeDouble(value: Double): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeString(value: String): JsonElement {
+        return JsonPrimitive(value)
+    }
+
+    override fun encodeList(size: Int): Transcoder.ListBuilder<JsonElement> {
+        val jsonList = JsonArray()
+        return object : Transcoder.ListBuilder<JsonElement> {
+
+            override fun add(value: JsonElement): Transcoder.ListBuilder<JsonElement> {
+                jsonList.add(value)
+                return this
+            }
+
+            override fun build(): JsonElement {
+                return jsonList
+            }
+        }
+    }
+
+    override fun encodeMap(): Transcoder.VirtualMapBuilder<JsonElement> {
+        val jsonMap = JsonObject()
+        return object : Transcoder.VirtualMapBuilder<JsonElement> {
+
+            override fun put(key: JsonElement, value: JsonElement): Transcoder.VirtualMapBuilder<JsonElement> {
+                put(key.asString, value)
+                return this
+            }
+
+            override fun put(key: String, value: JsonElement): Transcoder.VirtualMapBuilder<JsonElement> {
+                jsonMap.add(key, value)
+                return this
+            }
+
+            override fun build(): JsonElement {
+                return jsonMap
+            }
+        }
+    }
+
+    override fun decodeMap(value: JsonElement): Transcoder.VirtualMap<JsonElement> {
+        require(value is JsonObject) { "value is not JsonObject!" }
+        return object : Transcoder.VirtualMap<JsonElement> {
+
+            override fun getKeys(): Collection<String> {
+                return value.keySet()
+            }
+
+            override fun hasValue(key: String): Boolean {
+                return value.has(key)
+            }
+
+            override fun getValue(key: String): JsonElement {
+                return value.get(key)
+            }
+        }
+    }
+
+    override fun decodeList(value: JsonElement): List<JsonElement> {
+        require(value is JsonArray) { "value is not JsonArray" }
+        return value.asList()
+    }
+
+    override fun decodeString(value: JsonElement): String {
+        return value.asString
+    }
+
+    override fun decodeDouble(value: JsonElement): Double {
+        return value.asDouble
+    }
+
+    override fun decodeFloat(value: JsonElement): Float {
+        return value.asFloat
+    }
+
+    override fun decodeLong(value: JsonElement): Long {
+        return value.asLong
+    }
+
+    override fun decodeInt(value: JsonElement): Int {
+        return value.asInt
+    }
+
+    override fun decodeShort(value: JsonElement): Short {
+        return value.asShort
+    }
+
+    override fun decodeByte(value: JsonElement): Byte {
+        return value.asByte
+    }
+
+    override fun decodeBoolean(value: JsonElement): Boolean {
+        return value.asBoolean
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/transcoder/Transcoder.kt b/src/main/kotlin/io/github/dockyardmc/tide/transcoder/Transcoder.kt
new file mode 100644
index 0000000..da2e1c0
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/transcoder/Transcoder.kt
@@ -0,0 +1,101 @@
+package io.github.dockyardmc.tide.transcoder
+
+//the coder is WHAT? 🏳️‍⚧️🏳️‍⚧️🏳️‍⚧️
+interface Transcoder<T> {
+    fun encodeNull(): T
+
+    fun encodeBoolean(value: Boolean): T
+    fun decodeBoolean(value: T): Boolean
+
+    fun encodeByte(value: Byte): T
+    fun decodeByte(value: T): Byte
+
+    fun encodeShort(value: Short): T
+    fun decodeShort(value: T): Short
+
+    fun encodeInt(value: Int): T
+    fun decodeInt(value: T): Int
+
+    fun encodeLong(value: Long): T
+    fun decodeLong(value: T): Long
+
+    fun encodeFloat(value: Float): T
+    fun decodeFloat(value: T): Float
+
+    fun encodeDouble(value: Double): T
+    fun decodeDouble(value: T): Double
+
+    fun encodeString(value: String): T
+    fun decodeString(value: T): String
+
+    fun encodeList(size: Int): ListBuilder<T>
+    fun decodeList(value: T): List<T>
+    fun emptyList() = encodeList(0).build()
+
+    fun encodeMap(): VirtualMapBuilder<T>
+
+    fun decodeMap(value: T): VirtualMap<T>
+    fun emptyMap() = encodeMap().build()
+
+    fun encodeByteArray(value: ByteArray): T {
+        val list = encodeList(value.size)
+        value.forEach { byte -> list.add(encodeByte(byte)) }
+        return list.build()
+    }
+
+    fun decodeByteArray(value: T): ByteArray {
+        val bytes = mutableListOf<Byte>()
+        decodeList(value).forEach { item ->
+            bytes.add(decodeByte(item))
+        }
+        return bytes.toByteArray()
+    }
+
+    fun encodeIntArray(value: IntArray): T {
+        val list = encodeList(value.size)
+        value.forEach { int -> list.add(encodeInt(int)) }
+        return list.build()
+    }
+
+    fun decodeIntArray(value: T): IntArray {
+        val ints = mutableListOf<Int>()
+        decodeList(value).forEach { item ->
+            ints.add(decodeInt(item))
+        }
+        return ints.toIntArray()
+    }
+
+    fun encodeLongArray(value: LongArray): T {
+        val list = encodeList(value.size)
+        value.forEach { int -> list.add(encodeLong(int)) }
+        return list.build()
+    }
+
+    fun decodeLongArray(value: T): LongArray {
+        val longs = mutableListOf<Long>()
+        decodeList(value).forEach { item ->
+            longs.add(decodeLong(item))
+        }
+        return longs.toLongArray()
+    }
+
+    interface ListBuilder<T> {
+        fun add(value: T): ListBuilder<T>
+        fun build(): T
+    }
+
+    interface VirtualMap<T> {
+        fun getKeys(): Collection<String>
+        fun hasValue(key: String): Boolean
+        fun getValue(key: String): T
+
+        val size get() = getKeys().size
+        val isEmpty get() = getKeys().isEmpty()
+    }
+
+    interface VirtualMapBuilder<T> {
+        fun put(key: T, value: T): VirtualMapBuilder<T>
+        fun put(key: String, value: T): VirtualMapBuilder<T>
+        fun build(): T
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/transcoders/TomlTranscoder.kt b/src/main/kotlin/io/github/dockyardmc/tide/transcoders/TomlTranscoder.kt
deleted file mode 100644
index 12f39a5..0000000
--- a/src/main/kotlin/io/github/dockyardmc/tide/transcoders/TomlTranscoder.kt
+++ /dev/null
@@ -1,152 +0,0 @@
-package io.github.dockyardmc.tide.transcoders
-
-import com.moandjiezana.toml.TomlWriter
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Transcoder
-import java.lang.IllegalStateException
-import java.util.*
-import kotlin.jvm.java
-import kotlin.reflect.KClass
-
-object TomlTranscoder : Transcoder<Toml> {
-
-    override fun writeInt(format: Toml, field: String, value: Int) {
-        format.put(field, value)
-    }
-
-    override fun writeString(format: Toml, field: String, value: String) {
-        format.put(field, value)
-    }
-
-    override fun writeBoolean(format: Toml, field: String, value: Boolean) {
-        format.put(field, value)
-    }
-
-    override fun writeVarInt(format: Toml, field: String, value: Int) {
-        format.put(field, value)
-    }
-
-    override fun writeByteArray(format: Toml, field: String, value: ByteArray) {
-        format.put(field, value)
-    }
-
-    override fun writeUUID(format: Toml, field: String, value: UUID) {
-        format.put(field, value)
-    }
-
-    override fun writeLong(format: Toml, field: String, value: Long) {
-        format.put(field, value)
-    }
-
-    override fun writeFloat(format: Toml, field: String, value: Float) {
-        format.put(field, value)
-    }
-
-    override fun writeDouble(format: Toml, field: String, value: Double) {
-        format.put(field, value)
-    }
-
-    override fun writeByte(format: Toml, field: String, value: Byte) {
-        format.put(field, value)
-    }
-
-    override fun <D> writeOptional(format: Toml, field: String, value: D?, codec: Codec<D>) {
-        if(value == null) return
-        format.put(field, value)
-    }
-
-    override fun <D> readOptional(format: Toml, field: String, codec: Codec<D>): D? {
-        return format.getOrNull(field)
-    }
-
-    override fun <D> writeList(format: Toml, field: String, value: List<D>, codec: Codec<D>) {
-        format.put(field, value)
-    }
-
-    override fun <D> readList(format: Toml, field: String, codec: Codec<D>): List<D> {
-        return format.get<List<D>>(field)
-    }
-
-    override fun <K, V> writeMap(format: Toml, field: String, value: Map<K, V>, keyCodec: Codec<K>, valueCodec: Codec<V>) {
-        return
-    }
-
-    override fun <K, V> readMap(format: Toml, field: String, keyCodec: Codec<K>, valueCodec: Codec<V>): Map<K, V> {
-        return mapOf()
-    }
-
-    override fun <E> writeEnum(kClass: KClass<*>, format: Toml, field: String, value: E) {
-        format.put(field, (value as Enum<*>).name)
-    }
-
-    override fun <E> readEnum(kClass: KClass<*>, format: Toml, field: String): E {
-        val name = format.get<String>(field)
-        return kClass.java.enumConstants.first { constant -> (constant as Enum<*>).name == name } as E
-    }
-
-    override fun readInt(format: Toml, field: String): Int {
-        return format.get<Int>(field)
-    }
-
-    override fun readString(format: Toml, field: String): String {
-        return format.get<String>(field)
-    }
-
-    override fun readBoolean(format: Toml, field: String): Boolean {
-        return format.get(field)
-    }
-
-    override fun readVarInt(format: Toml, field: String): Int {
-        return format.get<Int>(field)
-    }
-
-    override fun readByteArray(format: Toml, field: String): ByteArray {
-        return format.get(field)
-    }
-
-    override fun readUUID(format: Toml, field: String): UUID {
-        return format.get(field)
-    }
-
-    override fun readLong(format: Toml, field: String): Long {
-        return format.get(field)
-    }
-
-    override fun readFloat(format: Toml, field: String): Float {
-        return format.get(field)
-    }
-
-    override fun readDouble(format: Toml, field: String): Double {
-        return format.get(field)
-    }
-
-    override fun readByte(format: Toml, field: String): Byte {
-        return format.get(field)
-    }
-
-}
-
-class Toml(private val map: MutableMap<String, Any> = mutableMapOf()) {
-
-    fun put(key: String, any: Any) {
-        map[key] = any
-    }
-
-    fun <T> getOrNull(key: String): T? {
-        return map[key] as T?
-    }
-
-    fun <T> get(key: String): T {
-        return getOrNull<T>(key) ?: throw IllegalStateException("Value with key `$key` is null (contents of map: $map)")
-    }
-
-    fun getAsString(): String {
-        return TomlWriter().write(map)
-    }
-
-    companion object {
-        fun fromString(string: String): Toml {
-            return Toml(com.moandjiezana.toml.Toml().read(string).toMap().toMutableMap())
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/tide/types/Either.kt b/src/main/kotlin/io/github/dockyardmc/tide/types/Either.kt
new file mode 100644
index 0000000..9b24d69
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/tide/types/Either.kt
@@ -0,0 +1,18 @@
+package io.github.dockyardmc.tide.types
+
+sealed interface Either<L, R> {
+
+    data class Left<L, R>(val value: L) : Either<L, R>
+
+    data class Right<L, R>(val value: R) : Either<L, R>
+
+    companion object {
+        fun <L, R> left(value: L): Either<L, R> {
+            return Left(value)
+        }
+
+        fun <L, R> right(value: R): Either<L, R> {
+            return Right(value)
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/CodecTest.kt b/src/test/kotlin/CodecTest.kt
deleted file mode 100644
index bf1a5d2..0000000
--- a/src/test/kotlin/CodecTest.kt
+++ /dev/null
@@ -1,151 +0,0 @@
-import com.google.gson.JsonObject
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import io.netty.buffer.Unpooled
-import java.util.*
-import kotlin.test.assertEquals
-
-class CodecTest {
-
-    private val uuid = UUID.fromString("0c9151e4-7083-418d-a29c-bbc58f7c741b")
-    private val player = Player("LukynkaCZE", null, mapOf(DisplayedSkinPart.HAT to true, DisplayedSkinPart.LEFT_PANTS to false), Location(Vector3d(0.0, 3.0, 6.9), World("main")))
-    val testObject = Test(player, 69, 4.20, 6L, 0x4, 3.3f, uuid, WrappedByteArray(Unpooled.buffer().writeBoolean(true).array()), TestEnum.OPTION3, false)
-
-    enum class DisplayedSkinPart(val bit: Byte) {
-        CAPE(0x01),
-        JACKET(0x02),
-        LEFT_SLEEVE(0x04),
-        RIGHT_SLEEVE(0x08),
-        LEFT_PANTS(0x10),
-        RIGHT_PANTS(0x20),
-        HAT(0x40),
-        UNUSED(0x80.toByte())
-    }
-
-    data class World(val name: String) {
-        companion object {
-            val codec = Codec.of(
-                "name", Codecs.String, World::name,
-                ::World
-            )
-        }
-    }
-
-    data class Vector3d(val x: Double, val y: Double, val z: Double) {
-        companion object {
-            val CODEC = Codec.of(
-                "x", Codecs.Double, Vector3d::x,
-                "y", Codecs.Double, Vector3d::y,
-                "z", Codecs.Double, Vector3d::z,
-                ::Vector3d
-            )
-        }
-    }
-
-    data class Location(val position: Vector3d, val world: World) {
-        companion object {
-            val CODEC = Codec.of(
-                "position", Vector3d.CODEC, Location::position,
-                "world", World.codec, Location::world,
-                ::Location
-            )
-        }
-    }
-
-    data class Player(
-        val username: String,
-        val uuid: UUID?,
-        val displayedSkinPart: Map<DisplayedSkinPart, Boolean>?,
-        val location: Location,
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "username", Codecs.String, Player::username,
-                "uuid", Codecs.UUID.optional(), Player::uuid,
-                "displayed_skin_parts", Codec.enum<DisplayedSkinPart>().mapAsKeyTo(Codecs.Boolean).optional(), Player::displayedSkinPart,
-                "location", Location.CODEC, Player::location,
-                ::Player
-            )
-        }
-    }
-
-    data class WrappedByteArray(val value: ByteArray) {
-
-        override fun equals(other: Any?): Boolean {
-            if (other == null || other !is WrappedByteArray) return false
-            if (other.value.size != this.value.size) return false
-            return true
-        }
-
-        override fun hashCode(): Int {
-            return value.size
-        }
-
-        companion object {
-            val codec = Codec.of(
-                "value", Codecs.ByteArray, WrappedByteArray::value,
-                ::WrappedByteArray
-            )
-        }
-    }
-
-    enum class TestEnum {
-        OPTION1,
-        OPTION2,
-        OPTION3,
-        OPTION4
-    }
-
-    data class Test(
-        val player: Player,
-        val int: Int,
-        val double: Double,
-        val long: Long,
-        val byte: Byte,
-        val float: Float,
-        val uuid: UUID,
-        val byteArray: WrappedByteArray,
-        val enum: TestEnum,
-        val boolean: Boolean,
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "player", Player.codec, Test::player,
-                "int", Codecs.Int, Test::int,
-                "double", Codecs.Double, Test::double,
-                "long", Codecs.Long, Test::long,
-                "byte", Codecs.Byte, Test::byte,
-                "float", Codecs.Float, Test::float,
-                "uuid", Codecs.UUID, Test::uuid,
-                "byteArray", WrappedByteArray.codec, Test::byteArray,
-                "enum", Codec.enum<TestEnum>(), Test::enum,
-                "boolean", Codecs.Boolean, Test::boolean,
-                ::Test
-            )
-        }
-    }
-
-    @kotlin.test.Test
-    fun testReadWriteNetwork() {
-        val buffer = Unpooled.buffer()
-
-        Test.codec.writeNetwork(buffer, testObject)
-
-        val newObject = Test.codec.readNetwork(buffer)
-
-        assertEquals(testObject, newObject)
-
-        buffer.release()
-    }
-
-    @kotlin.test.Test
-    fun testReadWriteJson() {
-        val json = JsonObject()
-
-        Test.codec.writeJson(json, testObject)
-
-        val newObject = Test.codec.readJson(json)
-
-        assertEquals(testObject, newObject)
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/ListCodecTest.kt b/src/test/kotlin/ListCodecTest.kt
deleted file mode 100644
index a038244..0000000
--- a/src/test/kotlin/ListCodecTest.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-import com.google.gson.JsonArray
-import com.google.gson.JsonObject
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import io.netty.buffer.Unpooled
-import org.junit.jupiter.api.assertThrows
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class ListCodecTest {
-
-    data class Person(val name: String, val age: Int) {
-        companion object {
-            val codec = Codec.of(
-                "name", Codecs.String, Person::name,
-                "age", Codecs.Int, Person::age,
-                ::Person
-            )
-        }
-    }
-
-    private val list = listOf<Person>(
-        Person("Maya", 23),
-        Person("Aso", 18),
-        Person("Kev", 25)
-    )
-
-    @Test
-    fun testReadWriteNetwork() {
-        val buffer = Unpooled.buffer()
-        Person.codec.list().writeNetwork(buffer, list)
-
-        val newList = Person.codec.list().readNetwork(buffer)
-        assertEquals(list, newList)
-        buffer.release()
-    }
-
-    @Test
-    fun testReadWriteJsonArrayRoot() {
-        val json = JsonArray()
-        Person.codec.list().writeJson(json, list)
-
-        val newList = Person.codec.list().readJson(json)
-        assertEquals(list, newList)
-        assertEquals("[Person(name=Maya, age=23), Person(name=Aso, age=18), Person(name=Kev, age=25)]", newList.toString())
-    }
-
-    @Test
-    fun testReadWriteJsonObjectRoot() {
-        val json = JsonObject()
-        assertThrows<IllegalStateException> {
-            Person.codec.list().writeJson(json, list)
-        }
-    }
-
-    @Test
-    fun testReadWriteJsonObject() {
-        val json = JsonObject()
-        Person.codec.list().writeJson(json, list, "awesome_people")
-
-        val newList = Person.codec.list().readJson(json, "awesome_people")
-        assertEquals(list, newList)
-        assertEquals("[Person(name=Maya, age=23), Person(name=Aso, age=18), Person(name=Kev, age=25)]", newList.toString())
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/MapCodecTest.kt b/src/test/kotlin/MapCodecTest.kt
deleted file mode 100644
index 7907e64..0000000
--- a/src/test/kotlin/MapCodecTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-import com.google.gson.JsonArray
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import io.netty.buffer.Unpooled
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class MapCodecTest {
-
-    data class Person(val name: String, val age: Int) {
-        companion object {
-            val codec = Codec.of(
-                "name", Codecs.String, Person::name,
-                "age", Codecs.Int, Person::age,
-                ::Person
-            )
-        }
-    }
-
-    private val shortPeople = mapOf<Person, Boolean>(
-        Person("Maya", 23) to false,
-        Person("Aso", 18) to true,
-        Person("Kev", 25) to false
-    )
-
-    @Test
-    fun testReadWriteNetwork() {
-        val buffer = Unpooled.buffer()
-        Person.codec.mapAsKeyTo(Codecs.Boolean).writeNetwork(buffer, shortPeople)
-
-        val newMap = Codecs.Boolean.mapAsValueTo(Person.codec).readNetwork(buffer)
-        assertEquals(shortPeople, newMap)
-        buffer.release()
-    }
-
-    @Test
-    fun testReadWriteJsonArray() {
-        val json = JsonArray()
-        Person.codec.mapAsKeyTo(Codecs.Boolean).writeJson(json, shortPeople)
-
-        val newMap = Codecs.Boolean.mapAsValueTo(Person.codec).readJson(json)
-        assertEquals(shortPeople, newMap)
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/OptionalCodecTest.kt b/src/test/kotlin/OptionalCodecTest.kt
deleted file mode 100644
index 88fc018..0000000
--- a/src/test/kotlin/OptionalCodecTest.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-import com.google.gson.JsonObject
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import io.netty.buffer.Unpooled
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class OptionalCodecTest {
-
-    data class NullableTest(val nullable: String?, val time: Long?) {
-        companion object {
-            val CODEC = Codec.of(
-                "nullable", Codecs.String.optional(), NullableTest::nullable,
-                "time", Codecs.Long.optional(), NullableTest::time,
-                ::NullableTest
-            )
-        }
-    }
-
-    data class NullableHolder(val someString: String, val list: List<NullableTest>) {
-        companion object {
-            val CODEC = Codec.of(
-                "some_string", Codecs.String, NullableHolder::someString,
-                "list", NullableTest.CODEC.list(), NullableHolder::list,
-                ::NullableHolder
-            )
-        }
-    }
-
-    private val nullableEmpty = NullableTest(null, 7897895L)
-    private val nullablePresent = NullableTest("hi", null)
-    private val holder = NullableHolder("tzest", mutableListOf(nullablePresent, nullableEmpty))
-
-    @Test
-    fun testNullableNetworkReadWrite() {
-        testNullableNetwork(nullableEmpty)
-        testNullableNetwork(nullablePresent)
-        testNullableHolderNetwork(holder)
-    }
-
-    @Test
-    fun testNullableJsonReadWrite() {
-        testNullableJson(nullableEmpty)
-        testNullableJson(nullablePresent)
-        testNullableHolderJson(holder)
-    }
-
-    private fun testNullableHolderNetwork(type: NullableHolder) {
-        val buffer = Unpooled.buffer()
-        NullableHolder.CODEC.writeNetwork(buffer, type)
-
-        val newNullable = NullableHolder.CODEC.readNetwork(buffer)
-        assertEquals(type, newNullable)
-        buffer.release()
-    }
-
-    private fun testNullableHolderJson(type: NullableHolder) {
-        val json = JsonObject()
-        NullableHolder.CODEC.writeJson(json, type)
-
-        val newNullable = NullableHolder.CODEC.readJson(json)
-        assertEquals(type, newNullable)
-    }
-
-    private fun testNullableNetwork(type: NullableTest) {
-        val buffer = Unpooled.buffer()
-        NullableTest.CODEC.writeNetwork(buffer, type)
-
-        val newNullable = NullableTest.CODEC.readNetwork(buffer)
-        assertEquals(type, newNullable)
-        buffer.release()
-    }
-
-    private fun testNullableJson(type: NullableTest) {
-        val json = JsonObject()
-        NullableTest.CODEC.writeJson(json, type)
-
-        val newNullable = NullableTest.CODEC.readJson(json)
-        assertEquals(type, newNullable)
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/PerformanceBenchmarks.kt b/src/test/kotlin/PerformanceBenchmarks.kt
deleted file mode 100644
index c1bb571..0000000
--- a/src/test/kotlin/PerformanceBenchmarks.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-import cz.lukynka.prettylog.LogType
-import cz.lukynka.prettylog.log
-import io.netty.buffer.Unpooled
-import kotlin.system.measureTimeMillis
-import kotlin.test.Test
-
-class PerformanceBenchmarks {
-
-    @Test
-    fun runBenchmarks() {
-        val testObject: CodecTest.Test
-
-        val create = measureTimeMillis {
-            testObject = CodecTest().testObject
-        }
-
-        val buffer = Unpooled.buffer()
-
-        val first = measureTimeMillis {
-            CodecTest.Test.codec.writeNetwork(buffer, testObject)
-        }
-
-        buffer.resetReaderIndex()
-
-        val subsequent = measureTimeMillis {
-            CodecTest.Test.codec.writeNetwork(buffer, testObject)
-        }
-
-        val hundred = measureTimeMillis {
-            repeat(100) { _ ->
-                CodecTest.Test.codec.writeNetwork(buffer, testObject)
-            }
-        }
-
-        log("Class create took: ${create}ms", LogType.PERFORMANCE)
-        log("First took: ${first}ms", LogType.PERFORMANCE)
-        log("Subsequent took: ${subsequent}ms", LogType.PERFORMANCE)
-        log("Hundred took: ${hundred}ms", LogType.PERFORMANCE)
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/PerformanceTest.kt b/src/test/kotlin/PerformanceTest.kt
deleted file mode 100644
index e8cea5d..0000000
--- a/src/test/kotlin/PerformanceTest.kt
+++ /dev/null
@@ -1,143 +0,0 @@
-import cz.lukynka.prettylog.LogType
-import cz.lukynka.prettylog.log
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import io.netty.buffer.Unpooled
-import java.util.*
-import kotlin.system.measureTimeMillis
-
-class PerformanceTest {
-
-    enum class DisplayedSkinPart(val bit: Byte) {
-        CAPE(0x01),
-        JACKET(0x02),
-        LEFT_SLEEVE(0x04),
-        RIGHT_SLEEVE(0x08),
-        LEFT_PANTS(0x10),
-        RIGHT_PANTS(0x20),
-        HAT(0x40),
-        UNUSED(0x80.toByte())
-    }
-
-    data class World(val name: String) {
-        companion object {
-            val codec = Codec.of(
-                "name", Codecs.String, World::name,
-                ::World
-            )
-        }
-    }
-
-    data class Vector3d(val x: Double, val y: Double, val z: Double) {
-        companion object {
-            val CODEC = Codec.of(
-                "x", Codecs.Double, Vector3d::x,
-                "y", Codecs.Double, Vector3d::y,
-                "z", Codecs.Double, Vector3d::z,
-                ::Vector3d
-            )
-        }
-    }
-
-    data class Location(val position: Vector3d, val world: World) {
-        companion object {
-            val CODEC = Codec.of(
-                "position", Vector3d.CODEC, Location::position,
-                "world", World.codec, Location::world,
-                ::Location
-            )
-        }
-    }
-
-    data class Player(
-        val username: String,
-        val uuid: UUID?,
-        val displayedSkinPart: Map<DisplayedSkinPart, Boolean>?,
-        val location: Location,
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "username", Codecs.String, Player::username,
-                "uuid", Codecs.UUID.optional(), Player::uuid,
-                "displayed_skin_parts", Codec.enum<DisplayedSkinPart>().mapAsKeyTo(Codecs.Boolean).optional(), Player::displayedSkinPart,
-                "location", Location.CODEC, Player::location,
-                ::Player
-            )
-        }
-    }
-
-    data class WrappedByteArray(val value: ByteArray) {
-
-        override fun equals(other: Any?): Boolean {
-            if (other == null || other !is WrappedByteArray) return false
-            if (other.value.size != this.value.size) return false
-            return true
-        }
-
-        override fun hashCode(): Int {
-            return value.size
-        }
-
-        companion object {
-            val codec = Codec.of(
-                "value", Codecs.ByteArray, WrappedByteArray::value,
-                ::WrappedByteArray
-            )
-        }
-    }
-
-    enum class TestEnum {
-        OPTION1,
-        OPTION2,
-        OPTION3,
-        OPTION4
-    }
-
-    data class Test(
-        val player: Player,
-        val int: Int,
-        val double: Double,
-        val long: Long,
-        val byte: Byte,
-        val float: Float,
-        val uuid: UUID,
-        val byteArray: WrappedByteArray,
-        val enum: TestEnum,
-        val boolean: Boolean,
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "player", Player.codec, Test::player,
-                "int", Codecs.Int, Test::int,
-                "double", Codecs.Double, Test::double,
-                "long", Codecs.Long, Test::long,
-                "byte", Codecs.Byte, Test::byte,
-                "float", Codecs.Float, Test::float,
-                "uuid", Codecs.UUID, Test::uuid,
-                "byteArray", WrappedByteArray.codec, Test::byteArray,
-                "enum", Codec.enum<TestEnum>(), Test::enum,
-                "boolean", Codecs.Boolean, Test::boolean,
-                ::Test
-            )
-        }
-    }
-
-    @org.junit.jupiter.api.Test
-    fun testKotlin() {
-        Codec
-        val time = measureTimeMillis {
-            val uuid = UUID.fromString("0c9151e4-7083-418d-a29c-bbc58f7c741b")
-            val player = Player("LukynkaCZE", null, mapOf(DisplayedSkinPart.HAT to true, DisplayedSkinPart.LEFT_PANTS to false), Location(Vector3d(0.0, 3.0, 6.9), World("main")))
-            val testObject = Test(player, 69, 4.20, 6L, 0x4, 3.3f, uuid, WrappedByteArray(Unpooled.buffer().writeBoolean(true).array()), TestEnum.OPTION3, false)
-        }
-        log("Took ${time}ms", LogType.DEBUG)
-        val time2 = measureTimeMillis {
-            CodecTest().testObject
-        }
-        log("Second took ${time2}ms", LogType.DEBUG)
-        val time3 = measureTimeMillis {
-            CodecTest().testObject
-        }
-        log("Third took ${time3}ms", LogType.DEBUG)
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/TranscoderTest.kt b/src/test/kotlin/TranscoderTest.kt
deleted file mode 100644
index 92b8ee0..0000000
--- a/src/test/kotlin/TranscoderTest.kt
+++ /dev/null
@@ -1,66 +0,0 @@
-import io.github.dockyardmc.tide.Codec
-import io.github.dockyardmc.tide.Codecs
-import java.util.*
-
-class TranscoderTest {
-
-    data class AnotherCoolClass(
-        val someString: String,
-        val someOptionalInt: Int?,
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "some_string", Codecs.String, AnotherCoolClass::someString,
-                "some_optional_int", Codecs.VarInt.optional(), AnotherCoolClass::someOptionalInt,
-                ::AnotherCoolClass
-            )
-        }
-    }
-
-    data class Meower(
-        val accessories: List<Accessory>,
-        val age: Int
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "accessories", Accessory.codec.list(), Meower::accessories,
-                "age", Codecs.Int, Meower::age,
-                ::Meower
-            )
-        }
-    }
-
-    data class Accessory(val name: String, val id: UUID) {
-        companion object {
-            val codec = Codec.of(
-                "name", Codecs.String, Accessory::name,
-                "id", Codecs.UUID, Accessory::id,
-                ::Accessory
-            )
-        }
-    }
-
-    enum class CoolClassType {
-        SLIGHTLY_COOL,
-        MODERATELY_COOL,
-        COOL,
-        VERY_COOL,
-        HYPE_ASF
-    }
-
-    data class CoolClass(
-        val anotherObject: AnotherCoolClass,
-        val meowerToNameMap: Map<Meower, String>,
-        val enum: CoolClassType?
-    ) {
-        companion object {
-            val codec = Codec.of(
-                "another_object", AnotherCoolClass.codec, CoolClass::anotherObject,
-                "meower_to_name_map", Meower.codec.mapAsKeyTo(Codecs.String), CoolClass::meowerToNameMap,
-                "enum", Codec.enum<CoolClassType>().optional(), CoolClass::enum,
-                ::CoolClass
-            )
-        }
-    }
-
-}
\ No newline at end of file
diff --git a/src/test/kotlin/io/github/dockyardmc/tide/StreamCodecTests.kt b/src/test/kotlin/io/github/dockyardmc/tide/StreamCodecTests.kt
new file mode 100644
index 0000000..1a31be0
--- /dev/null
+++ b/src/test/kotlin/io/github/dockyardmc/tide/StreamCodecTests.kt
@@ -0,0 +1,52 @@
+package io.github.dockyardmc.tide
+
+import io.github.dockyardmc.tide.stream.StreamCodec
+import io.netty.buffer.Unpooled
+import org.junit.jupiter.api.Test
+import java.util.*
+import kotlin.test.assertEquals
+
+class StreamCodecTests {
+
+    data class Player(val username: String, val uuid: UUID, val data: PlayerData?) {
+
+        companion object {
+            val STREAM_CODEC = StreamCodec.of(
+                StreamCodec.STRING, Player::username,
+                StreamCodec.UUID, Player::uuid,
+                PlayerData.STREAM_CODEC.optional(), Player::data,
+                ::Player
+            )
+        }
+
+        data class PlayerData(
+            val isGay: Boolean,
+            val banReason: String?,
+            val rank: Rank
+        ) {
+            companion object {
+                val STREAM_CODEC = StreamCodec.of(
+                    StreamCodec.BOOLEAN, PlayerData::isGay,
+                    StreamCodec.STRING.optional(), PlayerData::banReason,
+                    StreamCodec.enum<Rank>(), PlayerData::rank,
+                    ::PlayerData
+                )
+            }
+        }
+
+        enum class Rank {
+            ADMIN,
+            PLAYER,
+            MODERATOR
+        }
+    }
+
+    @Test
+    fun testWriteRead() {
+        val player = Player("LukynkaCZE", UUID.randomUUID(), Player.PlayerData(true, null, Player.Rank.ADMIN))
+        val buffer = Unpooled.buffer()
+        Player.STREAM_CODEC.write(buffer, player)
+        val decoded = Player.STREAM_CODEC.read(buffer)
+        assertEquals(player, decoded)
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/io/github/dockyardmc/tide/StructCodecTests.kt b/src/test/kotlin/io/github/dockyardmc/tide/StructCodecTests.kt
new file mode 100644
index 0000000..2f289b7
--- /dev/null
+++ b/src/test/kotlin/io/github/dockyardmc/tide/StructCodecTests.kt
@@ -0,0 +1,142 @@
+package io.github.dockyardmc.tide
+
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import com.google.gson.JsonParser
+import io.github.dockyardmc.tide.codec.Codec
+import io.github.dockyardmc.tide.codec.StructCodec
+import io.github.dockyardmc.tide.transcoder.JsonTranscoder
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+import kotlin.test.assertEquals
+
+class StructCodecTests {
+
+    data class Person(val name: String, val data: PersonData) {
+        companion object {
+            val CODEC = StructCodec.of(
+                "name", Codec.STRING, Person::name,
+                "data", PersonData.CODEC, Person::data,
+                ::Person
+            )
+        }
+
+        data class PersonData(val age: Int, val license: String?) {
+            companion object {
+                val CODEC = StructCodec.of(
+                    "age", Codec.INT, PersonData::age,
+                    "license", Codec.STRING.optional(), PersonData::license,
+                    ::PersonData
+                )
+            }
+        }
+    }
+
+    class Empty {
+        override fun equals(other: Any?): Boolean {
+            return other is Empty
+        }
+
+        override fun hashCode(): Int {
+            return 0
+        }
+    }
+
+    data class SingleField(val name: String) {
+        companion object {
+            val CODEC = StructCodec.of("name", Codec.STRING, SingleField::name, ::SingleField)
+        }
+    }
+
+    data class SingleFieldOptional(val name: String?) {
+        companion object {
+            val CODEC = StructCodec.of("name", Codec.STRING.optional(), SingleFieldOptional::name, ::SingleFieldOptional)
+        }
+    }
+
+    data class SingleFieldDefault(val name: String) {
+        companion object {
+            val CODEC = StructCodec.of("name", Codec.STRING.default("maya"), SingleFieldDefault::name, ::SingleFieldDefault)
+        }
+    }
+
+    data class InlineField(val name: String, val innerObject: InnerObject) {
+        companion object {
+            val CODEC = StructCodec.of(
+                "name", Codec.STRING, InlineField::name,
+                StructCodec.INLINE, InnerObject.CODEC, InlineField::innerObject,
+                ::InlineField
+            )
+        }
+
+        data class InnerObject(val value: String) {
+            companion object {
+                val CODEC = StructCodec.of("value", Codec.STRING, InnerObject::value, ::InnerObject)
+            }
+        }
+    }
+
+    @Test
+    fun emptyCodecTest() {
+        val codec = StructCodec.of(::Empty)
+        val result = codec.decode(JsonTranscoder, JsonObject())
+        assertEquals(result, Empty())
+    }
+
+    @Test
+    fun testSingleField() {
+        val result = SingleField.CODEC.decode(JsonTranscoder, json("{\"name\": \"maya\"}"))
+        assertEquals(SingleField("maya"), result)
+    }
+
+    @Test
+    fun testSingleFieldMissing() {
+        assertThrows<Exception> {
+            SingleField.CODEC.decode(JsonTranscoder, json("{}"))
+        }
+    }
+
+    @Test
+    fun testSingleFieldOptionalMissing() {
+        assertDoesNotThrow {
+            val result = SingleFieldOptional.CODEC.decode(JsonTranscoder, json("{}"))
+            assertEquals(SingleFieldOptional(null), result)
+        }
+        assertDoesNotThrow {
+            val result = SingleFieldOptional.CODEC.decode(JsonTranscoder, json("{\"name\": \"maya\"}"))
+            assertEquals(SingleFieldOptional("maya"), result)
+        }
+    }
+
+    @Test
+    fun testSingleFieldOptionalDefaultMissing() {
+        assertDoesNotThrow {
+            val result = SingleFieldDefault.CODEC.decode(JsonTranscoder, json("{}"))
+            assertEquals(SingleFieldDefault("maya"), result)
+        }
+    }
+
+    @Test
+    fun testInlineField() {
+        val result = InlineField.CODEC.decode(JsonTranscoder, json("{ \"name\": \"maya\", \"value\": \"inner_value\"}"))
+        assertEquals(InlineField("maya", InlineField.InnerObject("inner_value")), result)
+
+        val encodeResult = InlineField.CODEC.encode(JsonTranscoder, InlineField("maya", InlineField.InnerObject("inner_value")))
+        assertEquals(json("{ \"name\": \"maya\", \"value\": \"inner_value\"}"), encodeResult)
+    }
+
+    @Test
+    fun testEncodeDecode() {
+        val person = Person("Maya", Person.PersonData(69, null))
+
+        val encoded = Person.CODEC.encode(JsonTranscoder, person)
+        val decoded = Person.CODEC.decode(JsonTranscoder, encoded)
+
+        assertEquals(person, decoded)
+    }
+
+    private fun json(key: String): JsonElement {
+        return JsonParser().parse(key)
+    }
+}
\ No newline at end of file