diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 81f451a..7a24474 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,6 +36,19 @@ jobs:
           authToken: '${{ secrets.ATTIC_TOKEN }}'
       - run: nix build .#clippy
 
+  msrv:
+    runs-on: ubuntu-latest
+    needs: check
+    steps:
+      - uses: actions/checkout@v4
+      - uses: cachix/install-nix-action@v25
+      - uses: icewind1991/attic-action@v1
+        with:
+          name: ci
+          instance: https://cache.icewind.me
+          authToken: '${{ secrets.ATTIC_TOKEN }}'
+      - run: nix build .#msrv
+
   matrix:
     runs-on: ubuntu-latest
     outputs:
@@ -78,3 +91,19 @@ jobs:
           instance: https://cache.icewind.me
           authToken: '${{ secrets.ATTIC_TOKEN }}'
       - run: nix build .#test
+
+  check-schema:
+    runs-on: ubuntu-latest
+    needs: check
+    steps:
+      - uses: actions/checkout@v4
+      - uses: cachix/install-nix-action@v25
+      - uses: icewind1991/attic-action@v1
+        with:
+          name: ci
+          instance: https://cache.icewind.me
+          authToken: '${{ secrets.ATTIC_TOKEN }}'
+      - run: nix run .#demostf-parser-schema > schema.json
+      - run: |
+          git diff
+          git diff-index --quiet HEAD --
diff --git a/Cargo.lock b/Cargo.lock
index 878ba07..2ee021c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -25,9 +25,9 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
@@ -39,27 +39,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
-name = "atty"
-version = "0.2.14"
+name = "anstyle"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi",
- "libc",
- "winapi",
-]
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
 
 [[package]]
 name = "backtrace"
-version = "0.3.69"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
 dependencies = [
  "addr2line",
  "cc",
@@ -82,36 +77,31 @@ dependencies = [
 
 [[package]]
 name = "bitbuffer"
-version = "0.10.9"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525586993a118417512a49bada2d143319310891f48b0b116c8f64fbb6486c87"
+checksum = "367fd16a8072d50e8e205d88e684a7eec9ddfb756165a076ebe9ecc41fd82192"
 dependencies = [
  "bitbuffer_derive",
- "err-derive",
  "memchr",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
  "schemars",
  "serde",
+ "thiserror",
 ]
 
 [[package]]
 name = "bitbuffer_derive"
-version = "0.10.1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052a5a614540ae9bb7de25c2c86a94b6de7374cb7e3230f3128955bdaea62c3f"
+checksum = "d158db6773597efd161c929e48a7c1811acaa6f55cc189cff557042c8890f71a"
 dependencies = [
+ "merge",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
- "syn_util",
+ "structmeta",
+ "syn 2.0.58",
 ]
 
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
 [[package]]
 name = "bitflags"
 version = "2.4.2"
@@ -120,9 +110,9 @@ checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
 
 [[package]]
 name = "bumpalo"
-version = "3.14.0"
+version = "3.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
 
 [[package]]
 name = "cast"
@@ -132,12 +122,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.83"
+version = "1.0.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
-dependencies = [
- "libc",
-]
+checksum = "1fd97381a8cc6493395a5afc4c691c1084b3768db713b73aa215217aa245d153"
 
 [[package]]
 name = "cfg-if"
@@ -147,9 +134,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "ciborium"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "effd91f6c78e5a4ace8a5d3c0b6bfaec9e2baaef55f3efc00e45fb2e477ee926"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
 dependencies = [
  "ciborium-io",
  "ciborium-ll",
@@ -158,15 +145,15 @@ dependencies = [
 
 [[package]]
 name = "ciborium-io"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdf919175532b369853f5d5e20b26b43112613fd6fe7aee757e35f7a44642656"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
 
 [[package]]
 name = "ciborium-ll"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "defaa24ecc093c77630e6c15e17c51f5e187bf35ee514f4e2d67baaa96dae22b"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
  "ciborium-io",
  "half",
@@ -174,52 +161,56 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "3.2.25"
+version = "4.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123"
+checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
 dependencies = [
- "bitflags 1.3.2",
- "clap_lex",
- "indexmap 1.9.3",
- "textwrap",
+ "clap_builder",
 ]
 
 [[package]]
-name = "clap_lex"
-version = "0.2.4"
+name = "clap_builder"
+version = "4.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4"
 dependencies = [
- "os_str_bytes",
+ "anstyle",
+ "clap_lex",
 ]
 
+[[package]]
+name = "clap_lex"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
+
 [[package]]
 name = "console"
-version = "0.15.7"
+version = "0.15.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
 dependencies = [
  "encode_unicode",
  "lazy_static",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys",
 ]
 
 [[package]]
 name = "criterion"
-version = "0.4.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7c76e09c1aae2bc52b3d2f29e13c6572553b30c4aa1b8a49fd70de6412654cb"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
 dependencies = [
  "anes",
- "atty",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "itertools",
- "lazy_static",
- "num-traits 0.2.17",
+ "is-terminal",
+ "itertools 0.10.5",
+ "num-traits 0.2.18",
+ "once_cell",
  "oorandom",
  "plotters",
  "rayon",
@@ -238,39 +229,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
- "itertools",
+ "itertools 0.10.5",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
- "cfg-if",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.17"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "autocfg",
- "cfg-if",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.18"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c"
-dependencies = [
- "cfg-if",
-]
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "diff"
@@ -280,15 +271,15 @@ checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "545b22097d44f8a9581187cdf93de7a71e4722bf51200cfaba810865b49a495d"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
 
 [[package]]
 name = "either"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
 
 [[package]]
 name = "encode_unicode"
@@ -307,9 +298,9 @@ dependencies = [
 
 [[package]]
 name = "enumflags2"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5998b4f30320c9d93aed72f63af821bfdac50465b75428fce77b48ec482c3939"
+checksum = "3278c9d5fb675e0a51dabcf4c0d355f692b064171535ba72361be1528a9d8e8d"
 dependencies = [
  "enumflags2_derive",
  "serde",
@@ -317,13 +308,13 @@ dependencies = [
 
 [[package]]
 name = "enumflags2_derive"
-version = "0.7.8"
+version = "0.7.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f95e2801cd355d4a1a3e3953ce6ee5ae9603a5c833455343a8bfe3f44d418246"
+checksum = "5c785274071b1b420972453b306eeca06acf4633829db4223b58a2a8c5953bc4"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -353,14 +344,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys",
 ]
 
 [[package]]
 name = "fastrand"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
 
 [[package]]
 name = "fnv"
@@ -376,15 +367,13 @@ checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "half"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
 
 [[package]]
 name = "hashbrown"
@@ -394,12 +383,9 @@ checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 
 [[package]]
 name = "hermit-abi"
-version = "0.1.19"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
 [[package]]
 name = "iai"
@@ -409,36 +395,36 @@ checksum = "71a816c97c42258aa5834d07590b718b4c9a598944cd39a52dc25b351185d678"
 
 [[package]]
 name = "indexmap"
-version = "1.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.1.0"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.3",
+ "hashbrown",
 ]
 
 [[package]]
 name = "insta"
-version = "1.34.0"
+version = "1.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d64600be34b2fcfc267740a243fa7744441bb4947a619ac4e5bb6507f35fbfc"
+checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc"
 dependencies = [
  "console",
  "lazy_static",
  "linked-hash-map",
  "serde",
  "similar",
- "yaml-rust",
+]
+
+[[package]]
+name = "is-terminal"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys",
 ]
 
 [[package]]
@@ -450,11 +436,20 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jemalloc-sys"
@@ -478,9 +473,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.66"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cee9c64da59eae3b50095c18d3e74f8b73c0b86d2792824ff01bbce68ba229ca"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -511,9 +506,9 @@ checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
 [[package]]
 name = "log"
-version = "0.4.20"
+version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
 
 [[package]]
 name = "main_error"
@@ -532,28 +527,50 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.1"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+
+[[package]]
+name = "merge"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10bbef93abb1da61525bbc45eeaff6473a41907d19f8f9aa5168d214e10693e9"
+dependencies = [
+ "merge_derive",
+ "num-traits 0.2.18",
+]
+
+[[package]]
+name = "merge_derive"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+checksum = "209d075476da2e63b4b29e72a2ef627b840589588e71400a25e3565c4f849d07"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
 dependencies = [
  "adler",
 ]
 
 [[package]]
 name = "no-panic"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc56831a2ae584dc43a8b0b33f496e71fb4d43cf8c1c0a3fd932e6340bea1f81"
+checksum = "c711522eedec2a96bb3672ad60a03561cb28934ab1e9b97d2ecb58e07c79ef52"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -577,7 +594,7 @@ dependencies = [
  "num-integer",
  "num-iter",
  "num-rational",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
@@ -588,7 +605,7 @@ checksum = "5f6f7833f2cbf2360a6cfd58cd41a53aa7a90bd4c202f5b1c7dd2ed73c57b2c3"
 dependencies = [
  "autocfg",
  "num-integer",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
@@ -597,28 +614,27 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "747d632c0c558b87dbabbe6a82f3b4ae03720d0646ac5b7b4dae89394be5f2c5"
 dependencies = [
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
 name = "num-iter"
-version = "0.1.43"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
 dependencies = [
  "autocfg",
  "num-integer",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
@@ -630,7 +646,7 @@ dependencies = [
  "autocfg",
  "num-bigint",
  "num-integer",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
@@ -639,37 +655,37 @@ version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31"
 dependencies = [
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.17"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "num_enum"
-version = "0.5.11"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
+checksum = "02339744ee7253741199f897151b38e72257d13802d4ee837285cc2990a90845"
 dependencies = [
  "num_enum_derive",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.5.11"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
+checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -693,12 +709,6 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
-[[package]]
-name = "os_str_bytes"
-version = "6.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1"
-
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -707,35 +717,34 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
 [[package]]
 name = "parse-display"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6509d08722b53e8dafe97f2027b22ccbe3a5db83cb352931e9716b0aa44bc5c"
+checksum = "06af5f9333eb47bd9ba8462d612e37a8328a5cb80b13f0af4de4c3b89f52dee5"
 dependencies = [
- "once_cell",
  "parse-display-derive",
  "regex",
+ "regex-syntax 0.8.3",
 ]
 
 [[package]]
 name = "parse-display-derive"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68517892c8daf78da08c0db777fcc17e07f2f63ef70041718f8a7630ad84f341"
+checksum = "dc9252f259500ee570c75adcc4e317fa6f57a1e47747d622e0bf838002a7b790"
 dependencies = [
- "once_cell",
  "proc-macro2",
  "quote",
  "regex",
- "regex-syntax 0.7.5",
+ "regex-syntax 0.8.3",
  "structmeta",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.13"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
 
 [[package]]
 name = "plotters"
@@ -743,7 +752,7 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
 dependencies = [
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
  "plotters-backend",
  "plotters-svg",
  "wasm-bindgen",
@@ -777,21 +786,20 @@ dependencies = [
 
 [[package]]
 name = "prettyplease"
-version = "0.1.25"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
+checksum = "8d3928fb5db768cb86f891ff014f0144589297e3c6a1aba6ed7cecfdace270c7"
 dependencies = [
  "proc-macro2",
- "syn 1.0.109",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "proc-macro-crate"
-version = "1.3.1"
+version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
 dependencies = [
- "once_cell",
  "toml_edit",
 ]
 
@@ -821,9 +829,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.75"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907a61bd0f64c2f29cd1cf1dc34d05176426a3f504a78010f08416ddb7b13708"
+checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
 dependencies = [
  "unicode-ident",
 ]
@@ -839,9 +847,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
  "either",
  "rayon-core",
@@ -849,33 +857,24 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
-dependencies = [
- "bitflags 1.3.2",
-]
-
 [[package]]
 name = "regex"
-version = "1.10.2"
+version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.3",
- "regex-syntax 0.8.2",
+ "regex-automata 0.4.6",
+ "regex-syntax 0.8.3",
 ]
 
 [[package]]
@@ -889,13 +888,13 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.3"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.3",
 ]
 
 [[package]]
@@ -906,15 +905,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
 
 [[package]]
 name = "rustc-demangle"
@@ -924,28 +917,28 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
 name = "rustix"
-version = "0.38.30"
+version = "0.38.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "322394588aaf33c24007e8bb3238ee3e4c5c09c084ab32bc73890b99ff326bca"
+checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47"
 
 [[package]]
 name = "ryu"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 
 [[package]]
 name = "same-file"
@@ -958,9 +951,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "0.8.16"
+version = "0.8.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
+checksum = "0afe01b987fac84253ce8acd5c05af9941975e4dee5b4f2d826b6947be8ec2c7"
 dependencies = [
  "dyn-clone",
  "schemars_derive",
@@ -970,52 +963,52 @@ dependencies = [
 
 [[package]]
 name = "schemars_derive"
-version = "0.8.16"
+version = "0.8.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
+checksum = "d253e72f060451e9e5615a1686f3cb4ff87c4e70504c79bdab8fb3b010cd4e97"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 1.0.109",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "serde"
-version = "1.0.194"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b114498256798c94a0689e1a15fec6005dee8ac1f41de56404b67afc2a4b773"
+checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.194"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3385e45322e8f9931410f01b3031ec534c3947d0e94c18049af4d9f9907d4e0"
+checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "serde_derive_internals"
-version = "0.26.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
+checksum = "330f01ce65a3a5fe59a60c82f3c9a024b573b8a6e875bd233fe5f934e71d54e3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.111"
+version = "1.0.115"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4"
+checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd"
 dependencies = [
  "itoa",
  "ryu",
@@ -1030,7 +1023,7 @@ checksum = "0b2e6b945e9d3df726b65d6ee24060aff8e3533d431f677a9695db04eff9dfdb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -1044,15 +1037,15 @@ dependencies = [
 
 [[package]]
 name = "similar"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32fea41aca09ee824cc9724996433064c89f7777e60762749a4170a14abbfa21"
+checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
 
 [[package]]
 name = "smallvec"
-version = "1.11.2"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "snap"
@@ -1077,25 +1070,25 @@ dependencies = [
 
 [[package]]
 name = "structmeta"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ad9e09554f0456d67a69c1584c9798ba733a5b50349a6c0d0948710523922d"
+checksum = "2e1575d8d40908d70f6fd05537266b90ae71b15dbbe7a8b7dffa2b759306d329"
 dependencies = [
  "proc-macro2",
  "quote",
  "structmeta-derive",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "structmeta-derive"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a60bcaff7397072dca0017d1db428e30d5002e00b6847703e2e42005c95fbe00"
+checksum = "152a0b65a590ff6c3da95cabe2353ee04e6167c896b28e3b14478c2636c922fc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -1111,26 +1104,15 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.47"
+version = "2.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1726efe18f42ae774cc644f330953a5e7b3c3003d3edcecf18850fe9d4dd9afb"
+checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
-[[package]]
-name = "syn_util"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6754c4559b79657554e9d8a0d56e65e490c76d382b9c23108364ec4125dea23c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "synstructure"
 version = "0.12.6"
@@ -1145,48 +1127,52 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.9.0"
+version = "3.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
 dependencies = [
  "cfg-if",
  "fastrand",
- "redox_syscall",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys",
 ]
 
 [[package]]
 name = "test-case"
-version = "2.2.2"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21d6cf5a7dffb3f9dceec8e6b8ca528d9bd71d36c9f074defb548ce161f598c0"
+checksum = "eb2550dd13afcd286853192af8601920d959b14c401fcece38071d53bf0768a8"
 dependencies = [
  "test-case-macros",
 ]
 
 [[package]]
-name = "test-case-macros"
-version = "2.2.2"
+name = "test-case-core"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e45b7bf6e19353ddd832745c8fcf77a17a93171df7151187f26623f2b75b5b26"
+checksum = "adcb7fd841cd518e279be3d5a3eb0636409487998a4aff22f3de87b81e88384f"
 dependencies = [
  "cfg-if",
- "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.58",
 ]
 
 [[package]]
-name = "textwrap"
-version = "0.16.0"
+name = "test-case-macros"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+ "test-case-core",
+]
 
 [[package]]
 name = "tf-demo-parser"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "Inflector",
  "better-panic",
@@ -1197,12 +1183,12 @@ dependencies = [
  "fnv",
  "iai",
  "insta",
- "itertools",
+ "itertools 0.12.1",
  "jemallocator",
  "lazy_static",
  "main_error",
  "no-panic",
- "num-traits 0.2.17",
+ "num-traits 0.2.18",
  "num_enum",
  "parse-display",
  "pretty_assertions",
@@ -1215,7 +1201,7 @@ dependencies = [
  "serde_repr",
  "snap",
  "steamid-ng",
- "syn 1.0.109",
+ "syn 2.0.58",
  "tempfile",
  "test-case",
  "tracing",
@@ -1224,29 +1210,29 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.56"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54378c645627613241d077a3a79db965db602882668f9136ac42af9ecb730ad"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.56"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa0faa943b50f3db30a20aa7e265dbc66076993efed8463e8de414e5d06d3471"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
 name = "thread_local"
-version = "1.1.7"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1270,11 +1256,11 @@ checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
 
 [[package]]
 name = "toml_edit"
-version = "0.19.15"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "indexmap 2.1.0",
+ "indexmap",
  "toml_datetime",
  "winnow",
 ]
@@ -1298,7 +1284,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
 ]
 
 [[package]]
@@ -1366,9 +1352,9 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "walkdir"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
  "same-file",
  "winapi-util",
@@ -1376,9 +1362,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.89"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ed0d4f68a3015cc185aff4db9506a015f4b96f95303897bfa23f846db54064e"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
@@ -1386,24 +1372,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.89"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b56f625e64f3a1084ded111c4d5f477df9f8c92df113852fa5a374dbda78826"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.89"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0162dbf37223cd2afce98f3d0785506dcb8d266223983e4b5b525859e6e182b2"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1411,28 +1397,28 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.89"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.47",
+ "syn 2.0.58",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.89"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab9b36309365056cd639da3134bf87fa8f3d86008abf99e612384a6eecd459f"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
 name = "web-sys"
-version = "0.3.66"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50c24a44ec86bb68fbecd1b3efed7e85ea5621b39b35ef2766b66cd984f8010f"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -1469,37 +1455,13 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
-dependencies = [
- "windows-targets 0.42.2",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.0",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
+ "windows-targets",
 ]
 
 [[package]]
@@ -1508,117 +1470,66 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.0",
- "windows_aarch64_msvc 0.52.0",
- "windows_i686_gnu 0.52.0",
- "windows_i686_msvc 0.52.0",
- "windows_x86_64_gnu 0.52.0",
- "windows_x86_64_gnullvm 0.52.0",
- "windows_x86_64_msvc 0.52.0",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.2"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.0"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
 
 [[package]]
 name = "winnow"
-version = "0.5.32"
+version = "0.5.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8434aeec7b290e8da5c3f0d628cb0eac6cabcb31d14bb74f779a08109a5914d6"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
 dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "yaml-rust"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
-dependencies = [
- "linked-hash-map",
-]
-
 [[package]]
 name = "yansi"
 version = "0.5.1"
diff --git a/Cargo.toml b/Cargo.toml
index 44c3b98..099db19 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,14 @@
 [package]
 name = "tf-demo-parser"
 description = "parser for tf2 demo files"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Robin Appelman <robin@icewind.nl>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/demostf/parser"
 exclude = [ "tests/fuzz", "test_data" ]
 default-run = "parse_demo"
+rust-version = "1.70.0"
 
 [lib]
 name = "tf_demo_parser"
@@ -36,37 +37,37 @@ path = "src/bin/codegen.rs"
 required-features = ["codegen"]
 
 [dependencies]
-bitbuffer = { version = "0.10.9", features = ["serde"] }
-num_enum = "0.5.7"
-num-traits = "0.2.15"
-enumflags2 = { version = "0.7.8", features = ["serde"] }
-snap = "1.1.0"
-serde = { version = "1.0.152", features = ["derive", "rc"] }
-serde_json = "1.0.91"
-serde_repr = "0.1.10"
+bitbuffer = { version = "0.11.0", features = ["serde"] }
+num_enum = "0.7.2"
+num-traits = "0.2.18"
+enumflags2 = { version = "0.7.9", features = ["serde"] }
+snap = "1.1.1"
+serde = { version = "1.0.197", features = ["derive", "rc"] }
+serde_json = "1.0.115"
+serde_repr = "0.1.18"
 err-derive = "0.3.1"
-parse-display = "0.8.0"
+parse-display = "0.9.0"
 main_error = "0.1.2"
-jemallocator = { version = "0.5.0", optional = true }
+jemallocator = { version = "0.5.4", optional = true }
 better-panic = { version = "0.3.0", optional = true }
-no-panic = { version = "0.1.17", optional = true }
+no-panic = { version = "0.1.29", optional = true }
 fnv = "1.0.7"
 steamid-ng = "1.0.0"
-tracing = { version = "0.1.37", optional = true }
-tracing-subscriber = { version = "0.3.16", features = ["env-filter"], optional = true }
-itertools = "0.10.5"
+tracing = { version = "0.1.40", optional = true }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"], optional = true }
+itertools = "0.12.1"
 
 # schema
-schemars = { version = "0.8.11", optional = true }
+schemars = { version = "0.8.18", optional = true }
 
 # codegen
 quote = { version = "1", optional = true }
-syn = { version = "1", features = ["full"], optional = true }
+syn = { version = "2", features = ["full"], optional = true }
 Inflector = { version = "0.11", default-features = false, optional = true }
 proc-macro2 = { version = "1", optional = true }
 tempfile = { version = "3", optional = true }
 lazy_static = { version = "1", optional = true }
-prettyplease = { version = "0.1", optional = true }
+prettyplease = { version = "0.2", optional = true }
 
 [features]
 schema = ["schemars", "bitbuffer/schemars"]
@@ -74,14 +75,14 @@ trace = ["tracing", "tracing-subscriber"]
 codegen = ["better-panic", "quote", "syn", "Inflector", "proc-macro2", "tempfile", "lazy_static", "prettyplease"]
 
 [dev-dependencies]
-pretty_assertions = "1.3.0"
-test-case = "2.2.2"
+pretty_assertions = "1.4.0"
+test-case = "3.3.1"
 iai = "0.1.1"
-criterion = "0.4.0"
-insta = { version = "1.34.0", features = ["json"] }
+criterion = "0.5.1"
+insta = { version = "1.38.0", features = ["json"] }
 
 [profile.release]
-lto = true
+lto = "thin"
 
 [profile.dev]
 opt-level = 2
diff --git a/flake.lock b/flake.lock
index 5dbaf26..0d80c56 100644
--- a/flake.lock
+++ b/flake.lock
@@ -10,11 +10,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1689107909,
-        "narHash": "sha256-fb+zxf7AWesECHx1foXOM3NcKHLrdeXzGb6s2AhT6pE=",
+        "lastModified": 1705943642,
+        "narHash": "sha256-M/n8k0Ato/WGmNJjtIUQGoooVBXL1ahSveiCK772Dk8=",
         "owner": "icewind1991",
         "repo": "cross-naersk",
-        "rev": "51de54599de569e6faa2ee33dd659c5c028d9911",
+        "rev": "db45d5a45b69d7d246bc748a54cd3cbbd9c47e74",
         "type": "github"
       },
       "original": {
@@ -28,11 +28,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
         "type": "github"
       },
       "original": {
@@ -61,10 +61,10 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1702645756,
-        "narHash": "sha256-qKI6OR3TYJYQB3Q8mAZ+DG4o/BR9ptcv9UnRV2hzljc=",
-        "path": "/nix/store/7ix7lj4h8q5jl740bkwvpi611safrq0v-source",
-        "rev": "40c3c94c241286dd2243ea34d3aef8a488f9e4d0",
+        "lastModified": 1712168706,
+        "narHash": "sha256-XP24tOobf6GGElMd0ux90FEBalUtw6NkBSVh/RlA6ik=",
+        "path": "/nix/store/wcg8s4srapl39ibwvhwiy5b7kvyjy7vq-source",
+        "rev": "1487bdea619e4a7a53a4590c475deabb5a9d1bfb",
         "type": "path"
       },
       "original": {
@@ -74,11 +74,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1703345962,
-        "narHash": "sha256-hfdT9SYVQD5C99+R8WK3IAe4i7hnE0t/LVpZdkva7w0=",
+        "lastModified": 1712496542,
+        "narHash": "sha256-jqHViQtWnEVqPVthcApWaJuqOL+htCaG2GDLFtOPPUo=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "22c37d3a97260e831dc3295fafac83178d52565e",
+        "rev": "4f348e045072ddca7ad47f5d0bb1bb318b950b79",
         "type": "github"
       },
       "original": {
@@ -106,11 +106,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1703297543,
-        "narHash": "sha256-d4QlzcoSNzb/iZheWtjOyRxoBSaLETSpViENGEkxv9g=",
+        "lastModified": 1712456031,
+        "narHash": "sha256-vPM+DLCyiT3eKGdDBIxqsgBrbbB7lL0TR6R7FLhX1v8=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "fc77c8b416b1537522d30c710baaaaebf769f816",
+        "rev": "0e5eaa43f116d798c289b0bb831320a353efc905",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 3f716a0..00578eb 100644
--- a/flake.nix
+++ b/flake.nix
@@ -24,12 +24,13 @@
   in (eachDefaultSystem (system: let
       overlays = [
         (import rust-overlay)
-        (import ./overlay.nix)
+        (import ./nix/overlay.nix)
       ];
       pkgs = (import nixpkgs) {
         inherit system overlays;
       };
       lib = pkgs.lib;
+      inherit (builtins) listToAttrs fromTOML readFile;
 
       hostTarget = pkgs.hostPlatform.config;
       targets = [
@@ -62,6 +63,16 @@
       };
       hostNaersk = cross-naersk'.hostNaersk;
 
+      msrv = (fromTOML (readFile ./Cargo.toml)).package.rust-version;
+      msrvToolchain = pkgs.rust-bin.stable."${msrv}".default;
+      naerskMsrv = let
+        toolchain = msrvToolchain;
+      in
+        pkgs.callPackage naersk {
+          cargo = toolchain;
+          rustc = toolchain;
+        };
+
       mkHydraJobs = system: {
         parser = derivation {
           name = "parser";
@@ -76,6 +87,7 @@
           };
         };
       };
+      overlayPackages = builtins.attrNames ((import ./nix/overlay.nix) {} {});
     in rec {
       packages =
         lib.attrsets.genAttrs targets (target:
@@ -90,7 +102,7 @@
                 };
             }))
         // rec {
-          inherit (pkgs) demostf-parser demostf-parser-codegen demostf-parser-codegen-events demostf-parser-codegen-props;
+          inherit (pkgs) demostf-parser demostf-parser-codegen demostf-parser-codegen-events demostf-parser-codegen-props demostf-parser-schema;
           check = hostNaersk.buildPackage (nearskOpt
             // {
               mode = "check";
@@ -104,6 +116,10 @@
               release = false;
               mode = "test";
             });
+          msrv = naerskMsrv.buildPackage (nearskOpt
+            // {
+              mode = "check";
+            });
           default = demostf-parser;
         };
 
@@ -136,14 +152,16 @@
         };
       };
 
+      formatter = pkgs.alejandra;
+
       devShells.default = pkgs.mkShell {
         nativeBuildInputs = with pkgs; [rust-bin.stable.latest.default bacon cargo-edit cargo-outdated rustfmt clippy cargo-audit hyperfine valgrind cargo-insta cargo-semver-checks];
       };
     })
     // {
-      overlays.default = import ./overlay.nix;
+      overlays.default = import ./nix/overlay.nix;
       hydraJobs = eachSystem ["x86_64-linux" "aarch64-linux"] (system: {
-        parser = self.packages.${system}.tf-demo-parser;
+        parser = self.packages.${system}.demostf-parser;
       });
     });
 }
diff --git a/codegen.nix b/nix/codegen.nix
similarity index 61%
rename from codegen.nix
rename to nix/codegen.nix
index 75dca41..182ad03 100644
--- a/codegen.nix
+++ b/nix/codegen.nix
@@ -4,13 +4,16 @@
   lib,
 }: let
   inherit (lib.sources) sourceByRegex;
-  src = sourceByRegex ./. ["Cargo.*" "(src|benches)(/.*)?"];
 in
   rustPlatform.buildRustPackage {
     pname = "demostf-parser-codegen";
     version = "0.1.0";
 
-    src = lib.traceVal src;
+    cargoBuildFlags = ''
+      --bin codegen
+    '';
+
+    src = sourceByRegex ../. ["Cargo.*" "(src|benches)(/.*)?"];
 
     buildType = "debug";
     buildFeatures = ["codegen"];
@@ -18,6 +21,8 @@ in
     doCheck = false;
 
     cargoLock = {
-      lockFile = ./Cargo.lock;
+      lockFile = ../Cargo.lock;
     };
+
+    meta.mainProgram = "codegen";
   }
diff --git a/overlay.nix b/nix/overlay.nix
similarity index 60%
rename from overlay.nix
rename to nix/overlay.nix
index 915c97a..41d3585 100644
--- a/overlay.nix
+++ b/nix/overlay.nix
@@ -2,11 +2,12 @@ final: prev: {
   demostf-parser = final.callPackage ./parser.nix {};
   demostf-parser-codegen = final.callPackage ./codegen.nix {};
   demostf-parser-codegen-events = final.runCommand "gameevent_gen.rs" {} ''
-    ${final.demostf-parser-codegen}/bin/codegen ${./test_data/short-2024.dem} events > $out
+    ${final.demostf-parser-codegen}/bin/codegen ${../test_data/short-2024.dem} events > $out
     ${final.rustfmt}/bin/rustfmt $out
   '';
   demostf-parser-codegen-props = final.runCommand "sendprop_gen.rs" {} ''
-    ${final.demostf-parser-codegen}/bin/codegen ${./test_data/short-2024.dem} props > $out
+    ${final.demostf-parser-codegen}/bin/codegen ${../test_data/short-2024.dem} props > $out
     ${final.rustfmt}/bin/rustfmt $out
   '';
+  demostf-parser-schema = final.callPackage ./schema.nix {};
 }
diff --git a/nix/parser.nix b/nix/parser.nix
new file mode 100644
index 0000000..752c6d9
--- /dev/null
+++ b/nix/parser.nix
@@ -0,0 +1,24 @@
+{
+  stdenv,
+  rustPlatform,
+  lib,
+}: let
+  inherit (lib.sources) sourceByRegex;
+  src = sourceByRegex ../. ["Cargo.*" "(src|benches|tests|test_data)(/.*)?"];
+in
+  rustPlatform.buildRustPackage rec {
+    pname = "demostf-parser";
+    version = "0.1.0";
+
+    cargoBuildFlags = ''
+      --bin parse_demo
+    '';
+
+    inherit src;
+
+    doCheck = stdenv.system == "x86_64-linux"; # building the tests takes +- forever on aarch64 for some reason
+
+    cargoLock = {
+      lockFile = ../Cargo.lock;
+    };
+  }
diff --git a/nix/schema.nix b/nix/schema.nix
new file mode 100644
index 0000000..d820159
--- /dev/null
+++ b/nix/schema.nix
@@ -0,0 +1,28 @@
+{
+  stdenv,
+  rustPlatform,
+  lib,
+}: let
+  inherit (lib.sources) sourceByRegex;
+in
+  rustPlatform.buildRustPackage {
+    pname = "demostf-parser-schema";
+    version = "0.1.0";
+
+    cargoBuildFlags = ''
+      --bin schema
+    '';
+
+    src = sourceByRegex ../. ["Cargo.*" "(src|benches)(/.*)?"];
+
+    buildType = "debug";
+    buildFeatures = ["schema"];
+
+    doCheck = false;
+
+    cargoLock = {
+      lockFile = ../Cargo.lock;
+    };
+
+    meta.mainProgram = "schema";
+  }
diff --git a/parser.nix b/parser.nix
deleted file mode 100644
index 60d4cbb..0000000
--- a/parser.nix
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-  stdenv,
-  rustPlatform,
-  lib,
-}: let
-  inherit (lib.sources) sourceByRegex;
-  src = sourceByRegex ./. ["Cargo.*" "(src|benches|tests|test_data)(/.*)?"];
-in
-  rustPlatform.buildRustPackage rec {
-    pname = "demostf-parser";
-    version = "0.1.0";
-
-    inherit src;
-
-    cargoLock = {
-      lockFile = ./Cargo.lock;
-    };
-  }
diff --git a/schema.json b/schema.json
index fa65a80..63c633e 100644
--- a/schema.json
+++ b/schema.json
@@ -205,6 +205,13 @@
     }
   ],
   "definitions": {
+    "BaselineIndex": {
+      "type": "integer",
+      "enum": [
+        0,
+        1
+      ]
+    },
     "BitReadStream": {
       "type": "object",
       "required": [
@@ -12410,9 +12417,7 @@
           ],
           "properties": {
             "base_line": {
-              "type": "integer",
-              "format": "uint8",
-              "minimum": 0.0
+              "$ref": "#/definitions/BaselineIndex"
             },
             "delta": {
               "anyOf": [
@@ -12641,9 +12646,7 @@
       ],
       "properties": {
         "baseline_index": {
-          "type": "integer",
-          "format": "uint",
-          "minimum": 0.0
+          "$ref": "#/definitions/BaselineIndex"
         },
         "delay": {
           "type": [
@@ -12990,12 +12993,12 @@
       }
     },
     "UpdateType": {
-      "type": "string",
+      "type": "integer",
       "enum": [
-        "Preserve",
-        "Leave",
-        "Enter",
-        "Delete"
+        0,
+        1,
+        2,
+        3
       ]
     },
     "UserCmd": {
diff --git a/src/codegen/gameevent.rs b/src/codegen/gameevent.rs
index 1c72232..3f5865f 100644
--- a/src/codegen/gameevent.rs
+++ b/src/codegen/gameevent.rs
@@ -225,7 +225,9 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
     let span = Span::call_site();
 
     let imports = quote!(
-        use super::gamevent::{EventValue, GameEventDefinition, GameEventEntry, RawGameEvent};
+        use super::gamevent::{
+            EventValue, GameEventDefinition, GameEventEntry, RawGameEvent, GameEventValue,
+        };
         use crate::demo::Stream;
         use crate::{ParseError, Result};
         use bitbuffer::{BitRead, LittleEndian, BitWrite, BitWriteStream};
@@ -241,32 +243,31 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
             quote!(pub #name: #ty,)
         });
 
-        let name = Ident::new(
-            &format!("{}Event", get_event_name(event.event_type.as_str())),
-            span,
-        );
+        let field_getters = event.entries.iter().map(|entry| {
+            let raw_name = &entry.name;
+            let name = get_entry_name(&entry.name);
+            let ident = Ident::new(name.as_str(), span);
+
+            quote!(#raw_name => Ok(self.#ident.clone().into()))
+        });
+
+        let event_name = get_event_name(event.event_type.as_str());
+        let name = Ident::new(&format!("{event_name}Event"), span);
 
         let entry_readers = event.entries.iter().map(|entry| {
+            let raw_name = &entry.name;
             let name_str = get_entry_name(&entry.name);
             let name = Ident::new(&name_str, span);
             let ty = Ident::new(get_type_name(entry.kind), span);
 
             quote!(
-                #name: read_value::<#ty>(stream, iter.next(), #name_str)?,
+                #name: read_value::<#ty>(stream, definition.get_entry(#raw_name), #name_str)?,
             )
         });
 
-        let definition_iter = if event.entries.len() > 0 {
-            quote!(
-                let mut iter = definition.entries.iter();
-            )
-        } else {
-            quote!()
-        };
-
         quote!(
             #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-            #[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+            #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
             pub struct #name {
                 #(#fields)*
             }
@@ -274,12 +275,31 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
             impl #name {
                 #[allow(unused_variables)]
                 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-                    #definition_iter
-
                     Ok(#name {
                         #(#entry_readers)*
                     })
                 }
+
+                #[allow(unused_variables)]
+                fn get_field(&self, field: &str) -> Result<GameEventValue> {
+                    #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+                    match field {
+                        #(#field_getters,)*
+                        _ => Err(ParseError::MissingGameEventValue {
+                            ty: #event_name,
+                            field: field.into(),
+                        }),
+                    }
+                }
+
+                #[allow(unused_variables)]
+                fn write(&self, stream: &mut BitWriteStream<LittleEndian>, definition: &GameEventDefinition) -> Result<()> {
+                    for entry in &definition.entries {
+                        let value = self.get_field(&entry.name).unwrap_or_else(|_| entry.kind.default_value());
+                        stream.write(&value)?;
+                    }
+                    Ok(())
+                }
             }
         )
     });
@@ -353,7 +373,7 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
         let variant_name = Ident::new(&name, span);
 
         quote!(
-            GameEvent::#variant_name(event) => event.write(stream),
+            GameEvent::#variant_name(event) => event.write(stream, definition),
         )
     });
 
@@ -430,10 +450,10 @@ pub fn generate_game_events(demo: Demo) -> TokenStream {
                     GameEventType::Unknown(_) => GameEvent::Unknown(RawGameEvent::read(stream, definition)?),
                 })
             }
-            pub fn write(&self, stream: &mut BitWriteStream<LittleEndian>) -> bitbuffer::Result<()> {
+            pub fn write(&self, stream: &mut BitWriteStream<LittleEndian>, definition: &GameEventDefinition) -> Result<()> {
                 match &self {
                     #(#write_events)*
-                    GameEvent::Unknown(raw) => raw.write(stream),
+                    GameEvent::Unknown(raw) => Ok(raw.write(stream)?),
                 }
             }
             pub fn event_type(&self) -> GameEventType {
diff --git a/src/consthash.rs b/src/consthash.rs
index 9def394..42d16a0 100644
--- a/src/consthash.rs
+++ b/src/consthash.rs
@@ -14,6 +14,8 @@ impl ConstFnvHash {
 
         let mut i = 0;
         while i < bytes.len() {
+            // can't use better method in const fns
+            #[allow(clippy::indexing_slicing)]
             let byte = bytes[i];
             hash ^= byte as u64;
             hash = hash.wrapping_mul(0x100000001b3);
diff --git a/src/demo/gameevent_gen.rs b/src/demo/gameevent_gen.rs
index f9a3aa9..7ec8c5a 100644
--- a/src/demo/gameevent_gen.rs
+++ b/src/demo/gameevent_gen.rs
@@ -1,5 +1,7 @@
-use super::gamevent::{EventValue, GameEventDefinition, GameEventEntry, RawGameEvent};
 use crate::demo::data::MaybeUtf8String;
+use super::gamevent::{
+    EventValue, GameEventDefinition, GameEventEntry, GameEventValue, RawGameEvent,
+};
 use crate::demo::Stream;
 use crate::{ParseError, Result};
 use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
@@ -25,7 +27,7 @@ fn read_value<'a, T: EventValue + BitRead<'a, LittleEndian> + Default>(
     Ok(T::read(stream)?)
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerSpawnEvent {
     pub hostname: MaybeUtf8String,
     pub address: MaybeUtf8String,
@@ -41,51 +43,156 @@ pub struct ServerSpawnEvent {
 impl ServerSpawnEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerSpawnEvent {
-            hostname: read_value::<MaybeUtf8String>(stream, iter.next(), "hostname")?,
-            address: read_value::<MaybeUtf8String>(stream, iter.next(), "address")?,
-            ip: read_value::<u32>(stream, iter.next(), "ip")?,
-            port: read_value::<u16>(stream, iter.next(), "port")?,
-            game: read_value::<MaybeUtf8String>(stream, iter.next(), "game")?,
-            map_name: read_value::<MaybeUtf8String>(stream, iter.next(), "map_name")?,
-            max_players: read_value::<u32>(stream, iter.next(), "max_players")?,
-            os: read_value::<MaybeUtf8String>(stream, iter.next(), "os")?,
-            dedicated: read_value::<bool>(stream, iter.next(), "dedicated")?,
-            password: read_value::<bool>(stream, iter.next(), "password")?,
-        })
+            hostname: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("hostname"),
+                "hostname",
+            )?,
+            address: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("address"),
+                "address",
+            )?,
+            ip: read_value::<u32>(stream, definition.get_entry("ip"), "ip")?,
+            port: read_value::<u16>(stream, definition.get_entry("port"), "port")?,
+            game: read_value::<MaybeUtf8String>(stream, definition.get_entry("game"), "game")?,
+            map_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("mapname"),
+                "map_name",
+            )?,
+            max_players: read_value::<u32>(
+                stream,
+                definition.get_entry("maxplayers"),
+                "max_players",
+            )?,
+            os: read_value::<MaybeUtf8String>(stream, definition.get_entry("os"), "os")?,
+            dedicated: read_value::<bool>(stream, definition.get_entry("dedicated"), "dedicated")?,
+            password: read_value::<bool>(stream, definition.get_entry("password"), "password")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "hostname" => Ok(self.hostname.clone().into()),
+            "address" => Ok(self.address.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "port" => Ok(self.port.clone().into()),
+            "game" => Ok(self.game.clone().into()),
+            "mapname" => Ok(self.map_name.clone().into()),
+            "maxplayers" => Ok(self.max_players.clone().into()),
+            "os" => Ok(self.os.clone().into()),
+            "dedicated" => Ok(self.dedicated.clone().into()),
+            "password" => Ok(self.password.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerSpawn",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerChangeLevelFailedEvent {
     pub level_name: MaybeUtf8String,
 }
 impl ServerChangeLevelFailedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerChangeLevelFailedEvent {
-            level_name: read_value::<MaybeUtf8String>(stream, iter.next(), "level_name")?,
+            level_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("levelname"),
+                "level_name",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "levelname" => Ok(self.level_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerChangeLevelFailed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerShutdownEvent {
     pub reason: MaybeUtf8String,
 }
 impl ServerShutdownEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerShutdownEvent {
-            reason: read_value::<MaybeUtf8String>(stream, iter.next(), "reason")?,
+            reason: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("reason"),
+                "reason",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "reason" => Ok(self.reason.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerShutdown",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerCvarEvent {
     pub cvar_name: MaybeUtf8String,
     pub cvar_value: MaybeUtf8String,
@@ -93,29 +200,86 @@ pub struct ServerCvarEvent {
 impl ServerCvarEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerCvarEvent {
-            cvar_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cvar_name")?,
-            cvar_value: read_value::<MaybeUtf8String>(stream, iter.next(), "cvar_value")?,
+            cvar_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cvarname"),
+                "cvar_name",
+            )?,
+            cvar_value: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cvarvalue"),
+                "cvar_value",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cvarname" => Ok(self.cvar_name.clone().into()),
+            "cvarvalue" => Ok(self.cvar_value.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerCvar",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerMessageEvent {
     pub text: MaybeUtf8String,
 }
 impl ServerMessageEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerMessageEvent {
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerMessage",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerAddBanEvent {
     pub name: MaybeUtf8String,
     pub user_id: u16,
@@ -128,20 +292,58 @@ pub struct ServerAddBanEvent {
 impl ServerAddBanEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerAddBanEvent {
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            ip: read_value::<MaybeUtf8String>(stream, iter.next(), "ip")?,
-            duration: read_value::<MaybeUtf8String>(stream, iter.next(), "duration")?,
-            by: read_value::<MaybeUtf8String>(stream, iter.next(), "by")?,
-            kicked: read_value::<bool>(stream, iter.next(), "kicked")?,
-        })
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            ip: read_value::<MaybeUtf8String>(stream, definition.get_entry("ip"), "ip")?,
+            duration: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("duration"),
+                "duration",
+            )?,
+            by: read_value::<MaybeUtf8String>(stream, definition.get_entry("by"), "by")?,
+            kicked: read_value::<bool>(stream, definition.get_entry("kicked"), "kicked")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "name" => Ok(self.name.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "networkid" => Ok(self.network_id.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "duration" => Ok(self.duration.clone().into()),
+            "by" => Ok(self.by.clone().into()),
+            "kicked" => Ok(self.kicked.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerAddBan",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ServerRemoveBanEvent {
     pub network_id: MaybeUtf8String,
     pub ip: MaybeUtf8String,
@@ -150,16 +352,46 @@ pub struct ServerRemoveBanEvent {
 impl ServerRemoveBanEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ServerRemoveBanEvent {
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            ip: read_value::<MaybeUtf8String>(stream, iter.next(), "ip")?,
-            by: read_value::<MaybeUtf8String>(stream, iter.next(), "by")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            ip: read_value::<MaybeUtf8String>(stream, definition.get_entry("ip"), "ip")?,
+            by: read_value::<MaybeUtf8String>(stream, definition.get_entry("by"), "by")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "networkid" => Ok(self.network_id.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "by" => Ok(self.by.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ServerRemoveBan",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerConnectEvent {
     pub name: MaybeUtf8String,
     pub index: u8,
@@ -171,19 +403,56 @@ pub struct PlayerConnectEvent {
 impl PlayerConnectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerConnectEvent {
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-            index: read_value::<u8>(stream, iter.next(), "index")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            address: read_value::<MaybeUtf8String>(stream, iter.next(), "address")?,
-            bot: read_value::<u16>(stream, iter.next(), "bot")?,
-        })
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+            index: read_value::<u8>(stream, definition.get_entry("index"), "index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            address: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("address"),
+                "address",
+            )?,
+            bot: read_value::<u16>(stream, definition.get_entry("bot"), "bot")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "name" => Ok(self.name.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "networkid" => Ok(self.network_id.clone().into()),
+            "address" => Ok(self.address.clone().into()),
+            "bot" => Ok(self.bot.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerConnect",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerConnectClientEvent {
     pub name: MaybeUtf8String,
     pub index: u8,
@@ -194,18 +463,50 @@ pub struct PlayerConnectClientEvent {
 impl PlayerConnectClientEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerConnectClientEvent {
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-            index: read_value::<u8>(stream, iter.next(), "index")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            bot: read_value::<u16>(stream, iter.next(), "bot")?,
-        })
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+            index: read_value::<u8>(stream, definition.get_entry("index"), "index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            bot: read_value::<u16>(stream, definition.get_entry("bot"), "bot")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "name" => Ok(self.name.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "networkid" => Ok(self.network_id.clone().into()),
+            "bot" => Ok(self.bot.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerConnectClient",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerInfoEvent {
     pub name: MaybeUtf8String,
     pub index: u8,
@@ -216,18 +517,50 @@ pub struct PlayerInfoEvent {
 impl PlayerInfoEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerInfoEvent {
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-            index: read_value::<u8>(stream, iter.next(), "index")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            bot: read_value::<bool>(stream, iter.next(), "bot")?,
-        })
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+            index: read_value::<u8>(stream, definition.get_entry("index"), "index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            bot: read_value::<bool>(stream, definition.get_entry("bot"), "bot")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "name" => Ok(self.name.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "networkid" => Ok(self.network_id.clone().into()),
+            "bot" => Ok(self.bot.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerInfo",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDisconnectEvent {
     pub user_id: u16,
     pub reason: MaybeUtf8String,
@@ -238,32 +571,92 @@ pub struct PlayerDisconnectEvent {
 impl PlayerDisconnectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDisconnectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            reason: read_value::<MaybeUtf8String>(stream, iter.next(), "reason")?,
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-            network_id: read_value::<MaybeUtf8String>(stream, iter.next(), "network_id")?,
-            bot: read_value::<u16>(stream, iter.next(), "bot")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            reason: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("reason"),
+                "reason",
+            )?,
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+            network_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("networkid"),
+                "network_id",
+            )?,
+            bot: read_value::<u16>(stream, definition.get_entry("bot"), "bot")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "reason" => Ok(self.reason.clone().into()),
+            "name" => Ok(self.name.clone().into()),
+            "networkid" => Ok(self.network_id.clone().into()),
+            "bot" => Ok(self.bot.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDisconnect",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerActivateEvent {
     pub user_id: u16,
 }
 impl PlayerActivateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerActivateEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerActivate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerSayEvent {
     pub user_id: u16,
     pub text: MaybeUtf8String,
@@ -271,29 +664,82 @@ pub struct PlayerSayEvent {
 impl PlayerSayEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerSayEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerSay",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ClientDisconnectEvent {
     pub message: MaybeUtf8String,
 }
 impl ClientDisconnectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ClientDisconnectEvent {
-            message: read_value::<MaybeUtf8String>(stream, iter.next(), "message")?,
+            message: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("message"),
+                "message",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "message" => Ok(self.message.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ClientDisconnect",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ClientBeginConnectEvent {
     pub address: MaybeUtf8String,
     pub ip: u32,
@@ -303,17 +749,52 @@ pub struct ClientBeginConnectEvent {
 impl ClientBeginConnectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ClientBeginConnectEvent {
-            address: read_value::<MaybeUtf8String>(stream, iter.next(), "address")?,
-            ip: read_value::<u32>(stream, iter.next(), "ip")?,
-            port: read_value::<u16>(stream, iter.next(), "port")?,
-            source: read_value::<MaybeUtf8String>(stream, iter.next(), "source")?,
+            address: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("address"),
+                "address",
+            )?,
+            ip: read_value::<u32>(stream, definition.get_entry("ip"), "ip")?,
+            port: read_value::<u16>(stream, definition.get_entry("port"), "port")?,
+            source: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("source"),
+                "source",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "address" => Ok(self.address.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "port" => Ok(self.port.clone().into()),
+            "source" => Ok(self.source.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ClientBeginConnect",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ClientConnectedEvent {
     pub address: MaybeUtf8String,
     pub ip: u32,
@@ -322,16 +803,46 @@ pub struct ClientConnectedEvent {
 impl ClientConnectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ClientConnectedEvent {
-            address: read_value::<MaybeUtf8String>(stream, iter.next(), "address")?,
-            ip: read_value::<u32>(stream, iter.next(), "ip")?,
-            port: read_value::<u16>(stream, iter.next(), "port")?,
+            address: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("address"),
+                "address",
+            )?,
+            ip: read_value::<u32>(stream, definition.get_entry("ip"), "ip")?,
+            port: read_value::<u16>(stream, definition.get_entry("port"), "port")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "address" => Ok(self.address.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "port" => Ok(self.port.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ClientConnected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ClientFullConnectEvent {
     pub address: MaybeUtf8String,
     pub ip: u32,
@@ -340,25 +851,79 @@ pub struct ClientFullConnectEvent {
 impl ClientFullConnectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ClientFullConnectEvent {
-            address: read_value::<MaybeUtf8String>(stream, iter.next(), "address")?,
-            ip: read_value::<u32>(stream, iter.next(), "ip")?,
-            port: read_value::<u16>(stream, iter.next(), "port")?,
+            address: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("address"),
+                "address",
+            )?,
+            ip: read_value::<u32>(stream, definition.get_entry("ip"), "ip")?,
+            port: read_value::<u16>(stream, definition.get_entry("port"), "port")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "address" => Ok(self.address.clone().into()),
+            "ip" => Ok(self.ip.clone().into()),
+            "port" => Ok(self.port.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ClientFullConnect",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HostQuitEvent {}
 impl HostQuitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(HostQuitEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HostQuit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamInfoEvent {
     pub team_id: u8,
     pub team_name: MaybeUtf8String,
@@ -366,15 +931,44 @@ pub struct TeamInfoEvent {
 impl TeamInfoEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamInfoEvent {
-            team_id: read_value::<u8>(stream, iter.next(), "team_id")?,
-            team_name: read_value::<MaybeUtf8String>(stream, iter.next(), "team_name")?,
+            team_id: read_value::<u8>(stream, definition.get_entry("teamid"), "team_id")?,
+            team_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("teamname"),
+                "team_name",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "teamid" => Ok(self.team_id.clone().into()),
+            "teamname" => Ok(self.team_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamInfo",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamScoreEvent {
     pub team_id: u8,
     pub score: u16,
@@ -382,15 +976,40 @@ pub struct TeamScoreEvent {
 impl TeamScoreEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamScoreEvent {
-            team_id: read_value::<u8>(stream, iter.next(), "team_id")?,
-            score: read_value::<u16>(stream, iter.next(), "score")?,
+            team_id: read_value::<u8>(stream, definition.get_entry("teamid"), "team_id")?,
+            score: read_value::<u16>(stream, definition.get_entry("score"), "score")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "teamid" => Ok(self.team_id.clone().into()),
+            "score" => Ok(self.score.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamScore",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayBroadcastAudioEvent {
     pub team: u8,
     pub sound: MaybeUtf8String,
@@ -400,17 +1019,48 @@ pub struct TeamPlayBroadcastAudioEvent {
 impl TeamPlayBroadcastAudioEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayBroadcastAudioEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            sound: read_value::<MaybeUtf8String>(stream, iter.next(), "sound")?,
-            additional_flags: read_value::<u16>(stream, iter.next(), "additional_flags")?,
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            sound: read_value::<MaybeUtf8String>(stream, definition.get_entry("sound"), "sound")?,
+            additional_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("additional_flags"),
+                "additional_flags",
+            )?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "sound" => Ok(self.sound.clone().into()),
+            "additional_flags" => Ok(self.additional_flags.clone().into()),
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayBroadcastAudio",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerTeamEvent {
     pub user_id: u16,
     pub team: u8,
@@ -423,20 +1073,54 @@ pub struct PlayerTeamEvent {
 impl PlayerTeamEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerTeamEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            old_team: read_value::<u8>(stream, iter.next(), "old_team")?,
-            disconnect: read_value::<bool>(stream, iter.next(), "disconnect")?,
-            auto_team: read_value::<bool>(stream, iter.next(), "auto_team")?,
-            silent: read_value::<bool>(stream, iter.next(), "silent")?,
-            name: read_value::<MaybeUtf8String>(stream, iter.next(), "name")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            old_team: read_value::<u8>(stream, definition.get_entry("oldteam"), "old_team")?,
+            disconnect: read_value::<bool>(
+                stream,
+                definition.get_entry("disconnect"),
+                "disconnect",
+            )?,
+            auto_team: read_value::<bool>(stream, definition.get_entry("autoteam"), "auto_team")?,
+            silent: read_value::<bool>(stream, definition.get_entry("silent"), "silent")?,
+            name: read_value::<MaybeUtf8String>(stream, definition.get_entry("name"), "name")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "oldteam" => Ok(self.old_team.clone().into()),
+            "disconnect" => Ok(self.disconnect.clone().into()),
+            "autoteam" => Ok(self.auto_team.clone().into()),
+            "silent" => Ok(self.silent.clone().into()),
+            "name" => Ok(self.name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerTeam",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerClassEvent {
     pub user_id: u16,
     pub class: MaybeUtf8String,
@@ -444,15 +1128,40 @@ pub struct PlayerClassEvent {
 impl PlayerClassEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerClassEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            class: read_value::<MaybeUtf8String>(stream, iter.next(), "class")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            class: read_value::<MaybeUtf8String>(stream, definition.get_entry("class"), "class")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "class" => Ok(self.class.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerClass",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDeathEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -484,51 +1193,172 @@ pub struct PlayerDeathEvent {
 impl PlayerDeathEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDeathEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
-            stun_flags: read_value::<u16>(stream, iter.next(), "stun_flags")?,
-            death_flags: read_value::<u16>(stream, iter.next(), "death_flags")?,
-            silent_kill: read_value::<bool>(stream, iter.next(), "silent_kill")?,
+            stun_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("stun_flags"),
+                "stun_flags",
+            )?,
+            death_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("death_flags"),
+                "death_flags",
+            )?,
+            silent_kill: read_value::<bool>(
+                stream,
+                definition.get_entry("silent_kill"),
+                "silent_kill",
+            )?,
             player_penetrate_count: read_value::<u16>(
                 stream,
-                iter.next(),
+                definition.get_entry("playerpenetratecount"),
                 "player_penetrate_count",
             )?,
             assister_fallback: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("assister_fallback"),
                 "assister_fallback",
             )?,
-            kill_streak_total: read_value::<u16>(stream, iter.next(), "kill_streak_total")?,
-            kill_streak_wep: read_value::<u16>(stream, iter.next(), "kill_streak_wep")?,
-            kill_streak_assist: read_value::<u16>(stream, iter.next(), "kill_streak_assist")?,
-            kill_streak_victim: read_value::<u16>(stream, iter.next(), "kill_streak_victim")?,
-            ducks_streaked: read_value::<u16>(stream, iter.next(), "ducks_streaked")?,
-            duck_streak_total: read_value::<u16>(stream, iter.next(), "duck_streak_total")?,
-            duck_streak_assist: read_value::<u16>(stream, iter.next(), "duck_streak_assist")?,
-            duck_streak_victim: read_value::<u16>(stream, iter.next(), "duck_streak_victim")?,
-            rocket_jump: read_value::<bool>(stream, iter.next(), "rocket_jump")?,
-            weapon_def_index: read_value::<u32>(stream, iter.next(), "weapon_def_index")?,
-            crit_type: read_value::<u16>(stream, iter.next(), "crit_type")?,
-        })
+            kill_streak_total: read_value::<u16>(
+                stream,
+                definition.get_entry("kill_streak_total"),
+                "kill_streak_total",
+            )?,
+            kill_streak_wep: read_value::<u16>(
+                stream,
+                definition.get_entry("kill_streak_wep"),
+                "kill_streak_wep",
+            )?,
+            kill_streak_assist: read_value::<u16>(
+                stream,
+                definition.get_entry("kill_streak_assist"),
+                "kill_streak_assist",
+            )?,
+            kill_streak_victim: read_value::<u16>(
+                stream,
+                definition.get_entry("kill_streak_victim"),
+                "kill_streak_victim",
+            )?,
+            ducks_streaked: read_value::<u16>(
+                stream,
+                definition.get_entry("ducks_streaked"),
+                "ducks_streaked",
+            )?,
+            duck_streak_total: read_value::<u16>(
+                stream,
+                definition.get_entry("duck_streak_total"),
+                "duck_streak_total",
+            )?,
+            duck_streak_assist: read_value::<u16>(
+                stream,
+                definition.get_entry("duck_streak_assist"),
+                "duck_streak_assist",
+            )?,
+            duck_streak_victim: read_value::<u16>(
+                stream,
+                definition.get_entry("duck_streak_victim"),
+                "duck_streak_victim",
+            )?,
+            rocket_jump: read_value::<bool>(
+                stream,
+                definition.get_entry("rocket_jump"),
+                "rocket_jump",
+            )?,
+            weapon_def_index: read_value::<u32>(
+                stream,
+                definition.get_entry("weapon_def_index"),
+                "weapon_def_index",
+            )?,
+            crit_type: read_value::<u16>(stream, definition.get_entry("crit_type"), "crit_type")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            "stun_flags" => Ok(self.stun_flags.clone().into()),
+            "death_flags" => Ok(self.death_flags.clone().into()),
+            "silent_kill" => Ok(self.silent_kill.clone().into()),
+            "playerpenetratecount" => Ok(self.player_penetrate_count.clone().into()),
+            "assister_fallback" => Ok(self.assister_fallback.clone().into()),
+            "kill_streak_total" => Ok(self.kill_streak_total.clone().into()),
+            "kill_streak_wep" => Ok(self.kill_streak_wep.clone().into()),
+            "kill_streak_assist" => Ok(self.kill_streak_assist.clone().into()),
+            "kill_streak_victim" => Ok(self.kill_streak_victim.clone().into()),
+            "ducks_streaked" => Ok(self.ducks_streaked.clone().into()),
+            "duck_streak_total" => Ok(self.duck_streak_total.clone().into()),
+            "duck_streak_assist" => Ok(self.duck_streak_assist.clone().into()),
+            "duck_streak_victim" => Ok(self.duck_streak_victim.clone().into()),
+            "rocket_jump" => Ok(self.rocket_jump.clone().into()),
+            "weapon_def_index" => Ok(self.weapon_def_index.clone().into()),
+            "crit_type" => Ok(self.crit_type.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDeath",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHurtEvent {
     pub user_id: u16,
     pub health: u16,
@@ -545,24 +1375,74 @@ pub struct PlayerHurtEvent {
 impl PlayerHurtEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHurtEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            health: read_value::<u16>(stream, iter.next(), "health")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            damage_amount: read_value::<u16>(stream, iter.next(), "damage_amount")?,
-            custom: read_value::<u16>(stream, iter.next(), "custom")?,
-            show_disguised_crit: read_value::<bool>(stream, iter.next(), "show_disguised_crit")?,
-            crit: read_value::<bool>(stream, iter.next(), "crit")?,
-            mini_crit: read_value::<bool>(stream, iter.next(), "mini_crit")?,
-            all_see_crit: read_value::<bool>(stream, iter.next(), "all_see_crit")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            bonus_effect: read_value::<u8>(stream, iter.next(), "bonus_effect")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            health: read_value::<u16>(stream, definition.get_entry("health"), "health")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            damage_amount: read_value::<u16>(
+                stream,
+                definition.get_entry("damageamount"),
+                "damage_amount",
+            )?,
+            custom: read_value::<u16>(stream, definition.get_entry("custom"), "custom")?,
+            show_disguised_crit: read_value::<bool>(
+                stream,
+                definition.get_entry("showdisguisedcrit"),
+                "show_disguised_crit",
+            )?,
+            crit: read_value::<bool>(stream, definition.get_entry("crit"), "crit")?,
+            mini_crit: read_value::<bool>(stream, definition.get_entry("minicrit"), "mini_crit")?,
+            all_see_crit: read_value::<bool>(
+                stream,
+                definition.get_entry("allseecrit"),
+                "all_see_crit",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            bonus_effect: read_value::<u8>(
+                stream,
+                definition.get_entry("bonuseffect"),
+                "bonus_effect",
+            )?,
         })
     }
-}
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "health" => Ok(self.health.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "damageamount" => Ok(self.damage_amount.clone().into()),
+            "custom" => Ok(self.custom.clone().into()),
+            "showdisguisedcrit" => Ok(self.show_disguised_crit.clone().into()),
+            "crit" => Ok(self.crit.clone().into()),
+            "minicrit" => Ok(self.mini_crit.clone().into()),
+            "allseecrit" => Ok(self.all_see_crit.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "bonuseffect" => Ok(self.bonus_effect.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHurt",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerChatEvent {
     pub team_only: bool,
     pub user_id: u16,
@@ -571,16 +1451,42 @@ pub struct PlayerChatEvent {
 impl PlayerChatEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerChatEvent {
-            team_only: read_value::<bool>(stream, iter.next(), "team_only")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
-        })
+            team_only: read_value::<bool>(stream, definition.get_entry("teamonly"), "team_only")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "teamonly" => Ok(self.team_only.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerChat",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerScoreEvent {
     pub user_id: u16,
     pub kills: u16,
@@ -590,17 +1496,44 @@ pub struct PlayerScoreEvent {
 impl PlayerScoreEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerScoreEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            kills: read_value::<u16>(stream, iter.next(), "kills")?,
-            deaths: read_value::<u16>(stream, iter.next(), "deaths")?,
-            score: read_value::<u16>(stream, iter.next(), "score")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            kills: read_value::<u16>(stream, definition.get_entry("kills"), "kills")?,
+            deaths: read_value::<u16>(stream, definition.get_entry("deaths"), "deaths")?,
+            score: read_value::<u16>(stream, definition.get_entry("score"), "score")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "kills" => Ok(self.kills.clone().into()),
+            "deaths" => Ok(self.deaths.clone().into()),
+            "score" => Ok(self.score.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerScore",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerSpawnEvent {
     pub user_id: u16,
     pub team: u16,
@@ -609,16 +1542,42 @@ pub struct PlayerSpawnEvent {
 impl PlayerSpawnEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerSpawnEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            team: read_value::<u16>(stream, iter.next(), "team")?,
-            class: read_value::<u16>(stream, iter.next(), "class")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            team: read_value::<u16>(stream, definition.get_entry("team"), "team")?,
+            class: read_value::<u16>(stream, definition.get_entry("class"), "class")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "class" => Ok(self.class.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerSpawn",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerShootEvent {
     pub user_id: u16,
     pub weapon: u8,
@@ -627,16 +1586,42 @@ pub struct PlayerShootEvent {
 impl PlayerShootEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerShootEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            weapon: read_value::<u8>(stream, iter.next(), "weapon")?,
-            mode: read_value::<u8>(stream, iter.next(), "mode")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            weapon: read_value::<u8>(stream, definition.get_entry("weapon"), "weapon")?,
+            mode: read_value::<u8>(stream, definition.get_entry("mode"), "mode")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "mode" => Ok(self.mode.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerShoot",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerUseEvent {
     pub user_id: u16,
     pub entity: u16,
@@ -644,15 +1629,40 @@ pub struct PlayerUseEvent {
 impl PlayerUseEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerUseEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            entity: read_value::<u16>(stream, iter.next(), "entity")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            entity: read_value::<u16>(stream, definition.get_entry("entity"), "entity")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "entity" => Ok(self.entity.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerUse",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerChangeNameEvent {
     pub user_id: u16,
     pub old_name: MaybeUtf8String,
@@ -661,67 +1671,205 @@ pub struct PlayerChangeNameEvent {
 impl PlayerChangeNameEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerChangeNameEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            old_name: read_value::<MaybeUtf8String>(stream, iter.next(), "old_name")?,
-            new_name: read_value::<MaybeUtf8String>(stream, iter.next(), "new_name")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            old_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("oldname"),
+                "old_name",
+            )?,
+            new_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("newname"),
+                "new_name",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "oldname" => Ok(self.old_name.clone().into()),
+            "newname" => Ok(self.new_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerChangeName",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHintMessageEvent {
     pub hint_message: MaybeUtf8String,
 }
 impl PlayerHintMessageEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHintMessageEvent {
-            hint_message: read_value::<MaybeUtf8String>(stream, iter.next(), "hint_message")?,
+            hint_message: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("hintmessage"),
+                "hint_message",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "hintmessage" => Ok(self.hint_message.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHintMessage",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BasePlayerTeleportedEvent {
     pub ent_index: u16,
 }
 impl BasePlayerTeleportedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BasePlayerTeleportedEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BasePlayerTeleported",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameInitEvent {}
 impl GameInitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GameInitEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameInit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameNewMapEvent {
     pub map_name: MaybeUtf8String,
 }
 impl GameNewMapEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(GameNewMapEvent {
-            map_name: read_value::<MaybeUtf8String>(stream, iter.next(), "map_name")?,
+            map_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("mapname"),
+                "map_name",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "mapname" => Ok(self.map_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameNewMap",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameStartEvent {
     pub rounds_limit: u32,
     pub time_limit: u32,
@@ -731,31 +1879,90 @@ pub struct GameStartEvent {
 impl GameStartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(GameStartEvent {
-            rounds_limit: read_value::<u32>(stream, iter.next(), "rounds_limit")?,
-            time_limit: read_value::<u32>(stream, iter.next(), "time_limit")?,
-            frag_limit: read_value::<u32>(stream, iter.next(), "frag_limit")?,
-            objective: read_value::<MaybeUtf8String>(stream, iter.next(), "objective")?,
+            rounds_limit: read_value::<u32>(
+                stream,
+                definition.get_entry("roundslimit"),
+                "rounds_limit",
+            )?,
+            time_limit: read_value::<u32>(stream, definition.get_entry("timelimit"), "time_limit")?,
+            frag_limit: read_value::<u32>(stream, definition.get_entry("fraglimit"), "frag_limit")?,
+            objective: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("objective"),
+                "objective",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "roundslimit" => Ok(self.rounds_limit.clone().into()),
+            "timelimit" => Ok(self.time_limit.clone().into()),
+            "fraglimit" => Ok(self.frag_limit.clone().into()),
+            "objective" => Ok(self.objective.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameStart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameEndEvent {
     pub winner: u8,
 }
 impl GameEndEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(GameEndEvent {
-            winner: read_value::<u8>(stream, iter.next(), "winner")?,
+            winner: read_value::<u8>(stream, definition.get_entry("winner"), "winner")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "winner" => Ok(self.winner.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameEnd",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RoundStartEvent {
     pub time_limit: u32,
     pub frag_limit: u32,
@@ -764,16 +1971,46 @@ pub struct RoundStartEvent {
 impl RoundStartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RoundStartEvent {
-            time_limit: read_value::<u32>(stream, iter.next(), "time_limit")?,
-            frag_limit: read_value::<u32>(stream, iter.next(), "frag_limit")?,
-            objective: read_value::<MaybeUtf8String>(stream, iter.next(), "objective")?,
+            time_limit: read_value::<u32>(stream, definition.get_entry("timelimit"), "time_limit")?,
+            frag_limit: read_value::<u32>(stream, definition.get_entry("fraglimit"), "frag_limit")?,
+            objective: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("objective"),
+                "objective",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "timelimit" => Ok(self.time_limit.clone().into()),
+            "fraglimit" => Ok(self.frag_limit.clone().into()),
+            "objective" => Ok(self.objective.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RoundStart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RoundEndEvent {
     pub winner: u8,
     pub reason: u8,
@@ -782,16 +2019,46 @@ pub struct RoundEndEvent {
 impl RoundEndEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RoundEndEvent {
-            winner: read_value::<u8>(stream, iter.next(), "winner")?,
-            reason: read_value::<u8>(stream, iter.next(), "reason")?,
-            message: read_value::<MaybeUtf8String>(stream, iter.next(), "message")?,
+            winner: read_value::<u8>(stream, definition.get_entry("winner"), "winner")?,
+            reason: read_value::<u8>(stream, definition.get_entry("reason"), "reason")?,
+            message: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("message"),
+                "message",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "winner" => Ok(self.winner.clone().into()),
+            "reason" => Ok(self.reason.clone().into()),
+            "message" => Ok(self.message.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RoundEnd",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameMessageEvent {
     pub target: u8,
     pub text: MaybeUtf8String,
@@ -799,15 +2066,40 @@ pub struct GameMessageEvent {
 impl GameMessageEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(GameMessageEvent {
-            target: read_value::<u8>(stream, iter.next(), "target")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            target: read_value::<u8>(stream, definition.get_entry("target"), "target")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "target" => Ok(self.target.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameMessage",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BreakBreakableEvent {
     pub ent_index: u32,
     pub user_id: u16,
@@ -816,16 +2108,42 @@ pub struct BreakBreakableEvent {
 impl BreakBreakableEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BreakBreakableEvent {
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            material: read_value::<u8>(stream, iter.next(), "material")?,
-        })
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            material: read_value::<u8>(stream, definition.get_entry("material"), "material")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            "material" => Ok(self.material.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BreakBreakable",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BreakPropEvent {
     pub ent_index: u32,
     pub user_id: u16,
@@ -833,15 +2151,40 @@ pub struct BreakPropEvent {
 impl BreakPropEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BreakPropEvent {
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BreakProp",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EntityKilledEvent {
     pub ent_index_killed: u32,
     pub ent_index_attacker: u32,
@@ -851,17 +2194,60 @@ pub struct EntityKilledEvent {
 impl EntityKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EntityKilledEvent {
-            ent_index_killed: read_value::<u32>(stream, iter.next(), "ent_index_killed")?,
-            ent_index_attacker: read_value::<u32>(stream, iter.next(), "ent_index_attacker")?,
-            ent_index_inflictor: read_value::<u32>(stream, iter.next(), "ent_index_inflictor")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
+            ent_index_killed: read_value::<u32>(
+                stream,
+                definition.get_entry("entindex_killed"),
+                "ent_index_killed",
+            )?,
+            ent_index_attacker: read_value::<u32>(
+                stream,
+                definition.get_entry("entindex_attacker"),
+                "ent_index_attacker",
+            )?,
+            ent_index_inflictor: read_value::<u32>(
+                stream,
+                definition.get_entry("entindex_inflictor"),
+                "ent_index_inflictor",
+            )?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex_killed" => Ok(self.ent_index_killed.clone().into()),
+            "entindex_attacker" => Ok(self.ent_index_attacker.clone().into()),
+            "entindex_inflictor" => Ok(self.ent_index_inflictor.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EntityKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BonusUpdatedEvent {
     pub num_advanced: u16,
     pub num_bronze: u16,
@@ -871,17 +2257,48 @@ pub struct BonusUpdatedEvent {
 impl BonusUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BonusUpdatedEvent {
-            num_advanced: read_value::<u16>(stream, iter.next(), "num_advanced")?,
-            num_bronze: read_value::<u16>(stream, iter.next(), "num_bronze")?,
-            num_silver: read_value::<u16>(stream, iter.next(), "num_silver")?,
-            num_gold: read_value::<u16>(stream, iter.next(), "num_gold")?,
-        })
+            num_advanced: read_value::<u16>(
+                stream,
+                definition.get_entry("numadvanced"),
+                "num_advanced",
+            )?,
+            num_bronze: read_value::<u16>(stream, definition.get_entry("numbronze"), "num_bronze")?,
+            num_silver: read_value::<u16>(stream, definition.get_entry("numsilver"), "num_silver")?,
+            num_gold: read_value::<u16>(stream, definition.get_entry("numgold"), "num_gold")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "numadvanced" => Ok(self.num_advanced.clone().into()),
+            "numbronze" => Ok(self.num_bronze.clone().into()),
+            "numsilver" => Ok(self.num_silver.clone().into()),
+            "numgold" => Ok(self.num_gold.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BonusUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct AchievementEventEvent {
     pub achievement_name: MaybeUtf8String,
     pub cur_val: u16,
@@ -890,20 +2307,46 @@ pub struct AchievementEventEvent {
 impl AchievementEventEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(AchievementEventEvent {
             achievement_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("achievement_name"),
                 "achievement_name",
             )?,
-            cur_val: read_value::<u16>(stream, iter.next(), "cur_val")?,
-            max_val: read_value::<u16>(stream, iter.next(), "max_val")?,
+            cur_val: read_value::<u16>(stream, definition.get_entry("cur_val"), "cur_val")?,
+            max_val: read_value::<u16>(stream, definition.get_entry("max_val"), "max_val")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "achievement_name" => Ok(self.achievement_name.clone().into()),
+            "cur_val" => Ok(self.cur_val.clone().into()),
+            "max_val" => Ok(self.max_val.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "AchievementEvent",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct AchievementIncrementEvent {
     pub achievement_id: u32,
     pub cur_val: u16,
@@ -912,76 +2355,226 @@ pub struct AchievementIncrementEvent {
 impl AchievementIncrementEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(AchievementIncrementEvent {
-            achievement_id: read_value::<u32>(stream, iter.next(), "achievement_id")?,
-            cur_val: read_value::<u16>(stream, iter.next(), "cur_val")?,
-            max_val: read_value::<u16>(stream, iter.next(), "max_val")?,
+            achievement_id: read_value::<u32>(
+                stream,
+                definition.get_entry("achievement_id"),
+                "achievement_id",
+            )?,
+            cur_val: read_value::<u16>(stream, definition.get_entry("cur_val"), "cur_val")?,
+            max_val: read_value::<u16>(stream, definition.get_entry("max_val"), "max_val")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "achievement_id" => Ok(self.achievement_id.clone().into()),
+            "cur_val" => Ok(self.cur_val.clone().into()),
+            "max_val" => Ok(self.max_val.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "AchievementIncrement",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PhysgunPickupEvent {
     pub ent_index: u32,
 }
 impl PhysgunPickupEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PhysgunPickupEvent {
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PhysgunPickup",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FlareIgniteNpcEvent {
     pub ent_index: u32,
 }
 impl FlareIgniteNpcEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(FlareIgniteNpcEvent {
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FlareIgniteNpc",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HelicopterGrenadePuntMissEvent {}
 impl HelicopterGrenadePuntMissEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(HelicopterGrenadePuntMissEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HelicopterGrenadePuntMiss",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct UserDataDownloadedEvent {}
 impl UserDataDownloadedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(UserDataDownloadedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "UserDataDownloaded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RagdollDissolvedEvent {
     pub ent_index: u32,
 }
 impl RagdollDissolvedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RagdollDissolvedEvent {
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RagdollDissolved",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVChangedModeEvent {
     pub old_mode: u16,
     pub new_mode: u16,
@@ -990,16 +2583,46 @@ pub struct HLTVChangedModeEvent {
 impl HLTVChangedModeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVChangedModeEvent {
-            old_mode: read_value::<u16>(stream, iter.next(), "old_mode")?,
-            new_mode: read_value::<u16>(stream, iter.next(), "new_mode")?,
-            obs_target: read_value::<u16>(stream, iter.next(), "obs_target")?,
+            old_mode: read_value::<u16>(stream, definition.get_entry("oldmode"), "old_mode")?,
+            new_mode: read_value::<u16>(stream, definition.get_entry("newmode"), "new_mode")?,
+            obs_target: read_value::<u16>(
+                stream,
+                definition.get_entry("obs_target"),
+                "obs_target",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "oldmode" => Ok(self.old_mode.clone().into()),
+            "newmode" => Ok(self.new_mode.clone().into()),
+            "obs_target" => Ok(self.obs_target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVChangedMode",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVChangedTargetEvent {
     pub mode: u16,
     pub old_target: u16,
@@ -1008,25 +2631,83 @@ pub struct HLTVChangedTargetEvent {
 impl HLTVChangedTargetEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVChangedTargetEvent {
-            mode: read_value::<u16>(stream, iter.next(), "mode")?,
-            old_target: read_value::<u16>(stream, iter.next(), "old_target")?,
-            obs_target: read_value::<u16>(stream, iter.next(), "obs_target")?,
+            mode: read_value::<u16>(stream, definition.get_entry("mode"), "mode")?,
+            old_target: read_value::<u16>(
+                stream,
+                definition.get_entry("old_target"),
+                "old_target",
+            )?,
+            obs_target: read_value::<u16>(
+                stream,
+                definition.get_entry("obs_target"),
+                "obs_target",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "mode" => Ok(self.mode.clone().into()),
+            "old_target" => Ok(self.old_target.clone().into()),
+            "obs_target" => Ok(self.obs_target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVChangedTarget",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteEndedEvent {}
 impl VoteEndedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(VoteEndedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteEnded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteStartedEvent {
     pub issue: MaybeUtf8String,
     pub param_1: MaybeUtf8String,
@@ -1037,18 +2718,50 @@ pub struct VoteStartedEvent {
 impl VoteStartedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VoteStartedEvent {
-            issue: read_value::<MaybeUtf8String>(stream, iter.next(), "issue")?,
-            param_1: read_value::<MaybeUtf8String>(stream, iter.next(), "param_1")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            initiator: read_value::<u32>(stream, iter.next(), "initiator")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
-        })
+            issue: read_value::<MaybeUtf8String>(stream, definition.get_entry("issue"), "issue")?,
+            param_1: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("param1"),
+                "param_1",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            initiator: read_value::<u32>(stream, definition.get_entry("initiator"), "initiator")?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "issue" => Ok(self.issue.clone().into()),
+            "param1" => Ok(self.param_1.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "initiator" => Ok(self.initiator.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteStarted",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteChangedEvent {
     pub vote_option_1: u8,
     pub vote_option_2: u8,
@@ -1061,40 +2774,129 @@ pub struct VoteChangedEvent {
 impl VoteChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VoteChangedEvent {
-            vote_option_1: read_value::<u8>(stream, iter.next(), "vote_option_1")?,
-            vote_option_2: read_value::<u8>(stream, iter.next(), "vote_option_2")?,
-            vote_option_3: read_value::<u8>(stream, iter.next(), "vote_option_3")?,
-            vote_option_4: read_value::<u8>(stream, iter.next(), "vote_option_4")?,
-            vote_option_5: read_value::<u8>(stream, iter.next(), "vote_option_5")?,
-            potential_votes: read_value::<u8>(stream, iter.next(), "potential_votes")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
-        })
-    }
-}
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
-pub struct VotePassedEvent {
-    pub details: MaybeUtf8String,
-    pub param_1: MaybeUtf8String,
-    pub team: u8,
-    pub voteidx: u32,
+            vote_option_1: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option1"),
+                "vote_option_1",
+            )?,
+            vote_option_2: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option2"),
+                "vote_option_2",
+            )?,
+            vote_option_3: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option3"),
+                "vote_option_3",
+            )?,
+            vote_option_4: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option4"),
+                "vote_option_4",
+            )?,
+            vote_option_5: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option5"),
+                "vote_option_5",
+            )?,
+            potential_votes: read_value::<u8>(
+                stream,
+                definition.get_entry("potentialVotes"),
+                "potential_votes",
+            )?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "vote_option1" => Ok(self.vote_option_1.clone().into()),
+            "vote_option2" => Ok(self.vote_option_2.clone().into()),
+            "vote_option3" => Ok(self.vote_option_3.clone().into()),
+            "vote_option4" => Ok(self.vote_option_4.clone().into()),
+            "vote_option5" => Ok(self.vote_option_5.clone().into()),
+            "potentialVotes" => Ok(self.potential_votes.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+pub struct VotePassedEvent {
+    pub details: MaybeUtf8String,
+    pub param_1: MaybeUtf8String,
+    pub team: u8,
+    pub voteidx: u32,
 }
 impl VotePassedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VotePassedEvent {
-            details: read_value::<MaybeUtf8String>(stream, iter.next(), "details")?,
-            param_1: read_value::<MaybeUtf8String>(stream, iter.next(), "param_1")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
-        })
+            details: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("details"),
+                "details",
+            )?,
+            param_1: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("param1"),
+                "param_1",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "details" => Ok(self.details.clone().into()),
+            "param1" => Ok(self.param_1.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VotePassed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteFailedEvent {
     pub team: u8,
     pub voteidx: u32,
@@ -1102,15 +2904,40 @@ pub struct VoteFailedEvent {
 impl VoteFailedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VoteFailedEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteFailed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteCastEvent {
     pub vote_option: u8,
     pub team: u16,
@@ -1120,17 +2947,48 @@ pub struct VoteCastEvent {
 impl VoteCastEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VoteCastEvent {
-            vote_option: read_value::<u8>(stream, iter.next(), "vote_option")?,
-            team: read_value::<u16>(stream, iter.next(), "team")?,
-            entity_id: read_value::<u32>(stream, iter.next(), "entity_id")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
-        })
+            vote_option: read_value::<u8>(
+                stream,
+                definition.get_entry("vote_option"),
+                "vote_option",
+            )?,
+            team: read_value::<u16>(stream, definition.get_entry("team"), "team")?,
+            entity_id: read_value::<u32>(stream, definition.get_entry("entityid"), "entity_id")?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "vote_option" => Ok(self.vote_option.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "entityid" => Ok(self.entity_id.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteCast",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteOptionsEvent {
     pub count: u8,
     pub option_1: MaybeUtf8String,
@@ -1143,47 +3001,169 @@ pub struct VoteOptionsEvent {
 impl VoteOptionsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(VoteOptionsEvent {
-            count: read_value::<u8>(stream, iter.next(), "count")?,
-            option_1: read_value::<MaybeUtf8String>(stream, iter.next(), "option_1")?,
-            option_2: read_value::<MaybeUtf8String>(stream, iter.next(), "option_2")?,
-            option_3: read_value::<MaybeUtf8String>(stream, iter.next(), "option_3")?,
-            option_4: read_value::<MaybeUtf8String>(stream, iter.next(), "option_4")?,
-            option_5: read_value::<MaybeUtf8String>(stream, iter.next(), "option_5")?,
-            voteidx: read_value::<u32>(stream, iter.next(), "voteidx")?,
-        })
+            count: read_value::<u8>(stream, definition.get_entry("count"), "count")?,
+            option_1: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("option1"),
+                "option_1",
+            )?,
+            option_2: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("option2"),
+                "option_2",
+            )?,
+            option_3: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("option3"),
+                "option_3",
+            )?,
+            option_4: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("option4"),
+                "option_4",
+            )?,
+            option_5: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("option5"),
+                "option_5",
+            )?,
+            voteidx: read_value::<u32>(stream, definition.get_entry("voteidx"), "voteidx")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "count" => Ok(self.count.clone().into()),
+            "option1" => Ok(self.option_1.clone().into()),
+            "option2" => Ok(self.option_2.clone().into()),
+            "option3" => Ok(self.option_3.clone().into()),
+            "option4" => Ok(self.option_4.clone().into()),
+            "option5" => Ok(self.option_5.clone().into()),
+            "voteidx" => Ok(self.voteidx.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteOptions",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplaySavedEvent {}
 impl ReplaySavedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ReplaySavedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplaySaved",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EnteredPerformanceModeEvent {}
 impl EnteredPerformanceModeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(EnteredPerformanceModeEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EnteredPerformanceMode",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BrowseReplaysEvent {}
 impl BrowseReplaysEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(BrowseReplaysEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BrowseReplays",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplayYoutubeStatsEvent {
     pub views: u32,
     pub likes: u32,
@@ -1192,107 +3172,349 @@ pub struct ReplayYoutubeStatsEvent {
 impl ReplayYoutubeStatsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ReplayYoutubeStatsEvent {
-            views: read_value::<u32>(stream, iter.next(), "views")?,
-            likes: read_value::<u32>(stream, iter.next(), "likes")?,
-            favorited: read_value::<u32>(stream, iter.next(), "favorited")?,
-        })
+            views: read_value::<u32>(stream, definition.get_entry("views"), "views")?,
+            likes: read_value::<u32>(stream, definition.get_entry("likes"), "likes")?,
+            favorited: read_value::<u32>(stream, definition.get_entry("favorited"), "favorited")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "views" => Ok(self.views.clone().into()),
+            "likes" => Ok(self.likes.clone().into()),
+            "favorited" => Ok(self.favorited.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplayYoutubeStats",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct InventoryUpdatedEvent {}
 impl InventoryUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(InventoryUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "InventoryUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CartUpdatedEvent {}
 impl CartUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(CartUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CartUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StorePriceSheetUpdatedEvent {}
 impl StorePriceSheetUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(StorePriceSheetUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "StorePriceSheetUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EconInventoryConnectedEvent {}
 impl EconInventoryConnectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(EconInventoryConnectedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EconInventoryConnected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ItemSchemaInitializedEvent {}
 impl ItemSchemaInitializedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ItemSchemaInitializedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ItemSchemaInitialized",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GcNewSessionEvent {}
 impl GcNewSessionEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GcNewSessionEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GcNewSession",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GcLostSessionEvent {}
 impl GcLostSessionEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GcLostSessionEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GcLostSession",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct IntroFinishEvent {
     pub player: u16,
 }
 impl IntroFinishEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(IntroFinishEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "IntroFinish",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct IntroNextCameraEvent {
     pub player: u16,
 }
 impl IntroNextCameraEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(IntroNextCameraEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "IntroNextCamera",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerChangeClassEvent {
     pub user_id: u16,
     pub class: u16,
@@ -1300,43 +3522,120 @@ pub struct PlayerChangeClassEvent {
 impl PlayerChangeClassEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerChangeClassEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            class: read_value::<u16>(stream, iter.next(), "class")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            class: read_value::<u16>(stream, definition.get_entry("class"), "class")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "class" => Ok(self.class.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerChangeClass",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TfMapTimeRemainingEvent {
     pub seconds: u32,
 }
 impl TfMapTimeRemainingEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TfMapTimeRemainingEvent {
-            seconds: read_value::<u32>(stream, iter.next(), "seconds")?,
+            seconds: read_value::<u32>(stream, definition.get_entry("seconds"), "seconds")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "seconds" => Ok(self.seconds.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TfMapTimeRemaining",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TfGameOverEvent {
     pub reason: MaybeUtf8String,
 }
 impl TfGameOverEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TfGameOverEvent {
-            reason: read_value::<MaybeUtf8String>(stream, iter.next(), "reason")?,
+            reason: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("reason"),
+                "reason",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "reason" => Ok(self.reason.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TfGameOver",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CtfFlagCapturedEvent {
     pub capping_team: u16,
     pub capping_team_score: u16,
@@ -1344,80 +3643,233 @@ pub struct CtfFlagCapturedEvent {
 impl CtfFlagCapturedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CtfFlagCapturedEvent {
-            capping_team: read_value::<u16>(stream, iter.next(), "capping_team")?,
-            capping_team_score: read_value::<u16>(stream, iter.next(), "capping_team_score")?,
+            capping_team: read_value::<u16>(
+                stream,
+                definition.get_entry("capping_team"),
+                "capping_team",
+            )?,
+            capping_team_score: read_value::<u16>(
+                stream,
+                definition.get_entry("capping_team_score"),
+                "capping_team_score",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "capping_team" => Ok(self.capping_team.clone().into()),
+            "capping_team_score" => Ok(self.capping_team_score.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CtfFlagCaptured",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointInitializedEvent {}
 impl ControlPointInitializedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ControlPointInitializedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointInitialized",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointUpdateImagesEvent {
     pub index: u16,
 }
 impl ControlPointUpdateImagesEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointUpdateImagesEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointUpdateImages",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointUpdateLayoutEvent {
     pub index: u16,
 }
 impl ControlPointUpdateLayoutEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointUpdateLayoutEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointUpdateLayout",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointUpdateCappingEvent {
     pub index: u16,
 }
 impl ControlPointUpdateCappingEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointUpdateCappingEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointUpdateCapping",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointUpdateOwnerEvent {
     pub index: u16,
 }
 impl ControlPointUpdateOwnerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointUpdateOwnerEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointUpdateOwner",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointStartTouchEvent {
     pub player: u16,
     pub area: u16,
@@ -1425,15 +3877,40 @@ pub struct ControlPointStartTouchEvent {
 impl ControlPointStartTouchEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointStartTouchEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            area: read_value::<u16>(stream, iter.next(), "area")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            area: read_value::<u16>(stream, definition.get_entry("area"), "area")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "area" => Ok(self.area.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointStartTouch",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointEndTouchEvent {
     pub player: u16,
     pub area: u16,
@@ -1441,29 +3918,78 @@ pub struct ControlPointEndTouchEvent {
 impl ControlPointEndTouchEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointEndTouchEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            area: read_value::<u16>(stream, iter.next(), "area")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            area: read_value::<u16>(stream, definition.get_entry("area"), "area")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "area" => Ok(self.area.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointEndTouch",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointPulseElementEvent {
     pub player: u16,
 }
 impl ControlPointPulseElementEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointPulseElementEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointPulseElement",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointFakeCaptureEvent {
     pub player: u16,
     pub int_data: u16,
@@ -1471,15 +3997,40 @@ pub struct ControlPointFakeCaptureEvent {
 impl ControlPointFakeCaptureEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointFakeCaptureEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            int_data: read_value::<u16>(stream, iter.next(), "int_data")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            int_data: read_value::<u16>(stream, definition.get_entry("int_data"), "int_data")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "int_data" => Ok(self.int_data.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointFakeCapture",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointFakeCaptureMultiplierEvent {
     pub player: u16,
     pub int_data: u16,
@@ -1487,125 +4038,394 @@ pub struct ControlPointFakeCaptureMultiplierEvent {
 impl ControlPointFakeCaptureMultiplierEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointFakeCaptureMultiplierEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            int_data: read_value::<u16>(stream, iter.next(), "int_data")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            int_data: read_value::<u16>(stream, definition.get_entry("int_data"), "int_data")?,
         })
     }
-}
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
-pub struct TeamPlayRoundSelectedEvent {
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "int_data" => Ok(self.int_data.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointFakeCaptureMultiplier",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+pub struct TeamPlayRoundSelectedEvent {
     pub round: MaybeUtf8String,
 }
 impl TeamPlayRoundSelectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayRoundSelectedEvent {
-            round: read_value::<MaybeUtf8String>(stream, iter.next(), "round")?,
+            round: read_value::<MaybeUtf8String>(stream, definition.get_entry("round"), "round")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "round" => Ok(self.round.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundSelected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRoundStartEvent {
     pub full_reset: bool,
 }
 impl TeamPlayRoundStartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayRoundStartEvent {
-            full_reset: read_value::<bool>(stream, iter.next(), "full_reset")?,
+            full_reset: read_value::<bool>(
+                stream,
+                definition.get_entry("full_reset"),
+                "full_reset",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "full_reset" => Ok(self.full_reset.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundStart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRoundActiveEvent {}
 impl TeamPlayRoundActiveEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayRoundActiveEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundActive",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayWaitingBeginsEvent {}
 impl TeamPlayWaitingBeginsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayWaitingBeginsEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayWaitingBegins",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayWaitingEndsEvent {}
 impl TeamPlayWaitingEndsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayWaitingEndsEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayWaitingEnds",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayWaitingAboutToEndEvent {}
 impl TeamPlayWaitingAboutToEndEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayWaitingAboutToEndEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayWaitingAboutToEnd",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRestartRoundEvent {}
 impl TeamPlayRestartRoundEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayRestartRoundEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRestartRound",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayReadyRestartEvent {}
 impl TeamPlayReadyRestartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayReadyRestartEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayReadyRestart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRoundRestartSecondsEvent {
     pub seconds: u16,
 }
 impl TeamPlayRoundRestartSecondsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayRoundRestartSecondsEvent {
-            seconds: read_value::<u16>(stream, iter.next(), "seconds")?,
+            seconds: read_value::<u16>(stream, definition.get_entry("seconds"), "seconds")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "seconds" => Ok(self.seconds.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundRestartSeconds",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayTeamReadyEvent {
     pub team: u8,
 }
 impl TeamPlayTeamReadyEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayTeamReadyEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayTeamReady",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRoundWinEvent {
     pub team: u8,
     pub win_reason: u8,
@@ -1618,121 +4438,395 @@ pub struct TeamPlayRoundWinEvent {
 impl TeamPlayRoundWinEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayRoundWinEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            win_reason: read_value::<u8>(stream, iter.next(), "win_reason")?,
-            flag_cap_limit: read_value::<u16>(stream, iter.next(), "flag_cap_limit")?,
-            full_round: read_value::<u16>(stream, iter.next(), "full_round")?,
-            round_time: read_value::<f32>(stream, iter.next(), "round_time")?,
-            losing_team_num_caps: read_value::<u16>(stream, iter.next(), "losing_team_num_caps")?,
-            was_sudden_death: read_value::<u8>(stream, iter.next(), "was_sudden_death")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            win_reason: read_value::<u8>(stream, definition.get_entry("winreason"), "win_reason")?,
+            flag_cap_limit: read_value::<u16>(
+                stream,
+                definition.get_entry("flagcaplimit"),
+                "flag_cap_limit",
+            )?,
+            full_round: read_value::<u16>(
+                stream,
+                definition.get_entry("full_round"),
+                "full_round",
+            )?,
+            round_time: read_value::<f32>(
+                stream,
+                definition.get_entry("round_time"),
+                "round_time",
+            )?,
+            losing_team_num_caps: read_value::<u16>(
+                stream,
+                definition.get_entry("losing_team_num_caps"),
+                "losing_team_num_caps",
+            )?,
+            was_sudden_death: read_value::<u8>(
+                stream,
+                definition.get_entry("was_sudden_death"),
+                "was_sudden_death",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "winreason" => Ok(self.win_reason.clone().into()),
+            "flagcaplimit" => Ok(self.flag_cap_limit.clone().into()),
+            "full_round" => Ok(self.full_round.clone().into()),
+            "round_time" => Ok(self.round_time.clone().into()),
+            "losing_team_num_caps" => Ok(self.losing_team_num_caps.clone().into()),
+            "was_sudden_death" => Ok(self.was_sudden_death.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundWin",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayUpdateTimerEvent {}
 impl TeamPlayUpdateTimerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayUpdateTimerEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayUpdateTimer",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayRoundStalemateEvent {
     pub reason: u8,
 }
 impl TeamPlayRoundStalemateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayRoundStalemateEvent {
-            reason: read_value::<u8>(stream, iter.next(), "reason")?,
+            reason: read_value::<u8>(stream, definition.get_entry("reason"), "reason")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "reason" => Ok(self.reason.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayRoundStalemate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayOvertimeBeginEvent {}
 impl TeamPlayOvertimeBeginEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayOvertimeBeginEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayOvertimeBegin",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayOvertimeEndEvent {}
 impl TeamPlayOvertimeEndEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlayOvertimeEndEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayOvertimeEnd",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlaySuddenDeathBeginEvent {}
 impl TeamPlaySuddenDeathBeginEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlaySuddenDeathBeginEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlaySuddenDeathBegin",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlaySuddenDeathEndEvent {}
 impl TeamPlaySuddenDeathEndEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlaySuddenDeathEndEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlaySuddenDeathEnd",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayGameOverEvent {
     pub reason: MaybeUtf8String,
 }
 impl TeamPlayGameOverEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayGameOverEvent {
-            reason: read_value::<MaybeUtf8String>(stream, iter.next(), "reason")?,
+            reason: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("reason"),
+                "reason",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "reason" => Ok(self.reason.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayGameOver",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayMapTimeRemainingEvent {
     pub seconds: u16,
 }
 impl TeamPlayMapTimeRemainingEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayMapTimeRemainingEvent {
-            seconds: read_value::<u16>(stream, iter.next(), "seconds")?,
+            seconds: read_value::<u16>(stream, definition.get_entry("seconds"), "seconds")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "seconds" => Ok(self.seconds.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayMapTimeRemaining",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayTimerFlashEvent {
     pub time_remaining: u16,
 }
 impl TeamPlayTimerFlashEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayTimerFlashEvent {
-            time_remaining: read_value::<u16>(stream, iter.next(), "time_remaining")?,
+            time_remaining: read_value::<u16>(
+                stream,
+                definition.get_entry("time_remaining"),
+                "time_remaining",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "time_remaining" => Ok(self.time_remaining.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayTimerFlash",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayTimerTimeAddedEvent {
     pub timer: u16,
     pub seconds_added: u16,
@@ -1740,15 +4834,44 @@ pub struct TeamPlayTimerTimeAddedEvent {
 impl TeamPlayTimerTimeAddedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayTimerTimeAddedEvent {
-            timer: read_value::<u16>(stream, iter.next(), "timer")?,
-            seconds_added: read_value::<u16>(stream, iter.next(), "seconds_added")?,
+            timer: read_value::<u16>(stream, definition.get_entry("timer"), "timer")?,
+            seconds_added: read_value::<u16>(
+                stream,
+                definition.get_entry("seconds_added"),
+                "seconds_added",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "timer" => Ok(self.timer.clone().into()),
+            "seconds_added" => Ok(self.seconds_added.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayTimerTimeAdded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayPointStartCaptureEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1760,19 +4883,56 @@ pub struct TeamPlayPointStartCaptureEvent {
 impl TeamPlayPointStartCaptureEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayPointStartCaptureEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            cap_team: read_value::<u8>(stream, iter.next(), "cap_team")?,
-            cappers: read_value::<MaybeUtf8String>(stream, iter.next(), "cappers")?,
-            cap_time: read_value::<f32>(stream, iter.next(), "cap_time")?,
-        })
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            cap_team: read_value::<u8>(stream, definition.get_entry("capteam"), "cap_team")?,
+            cappers: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cappers"),
+                "cappers",
+            )?,
+            cap_time: read_value::<f32>(stream, definition.get_entry("captime"), "cap_time")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "capteam" => Ok(self.cap_team.clone().into()),
+            "cappers" => Ok(self.cappers.clone().into()),
+            "captime" => Ok(self.cap_time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayPointStartCapture",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayPointCapturedEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1782,17 +4942,52 @@ pub struct TeamPlayPointCapturedEvent {
 impl TeamPlayPointCapturedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayPointCapturedEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            cappers: read_value::<MaybeUtf8String>(stream, iter.next(), "cappers")?,
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            cappers: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cappers"),
+                "cappers",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "cappers" => Ok(self.cappers.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayPointCaptured",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayPointLockedEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1801,16 +4996,46 @@ pub struct TeamPlayPointLockedEvent {
 impl TeamPlayPointLockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayPointLockedEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayPointLocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayPointUnlockedEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1819,16 +5044,46 @@ pub struct TeamPlayPointUnlockedEvent {
 impl TeamPlayPointUnlockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayPointUnlockedEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayPointUnlocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayCaptureBrokenEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1837,16 +5092,50 @@ pub struct TeamPlayCaptureBrokenEvent {
 impl TeamPlayCaptureBrokenEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayCaptureBrokenEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            time_remaining: read_value::<f32>(stream, iter.next(), "time_remaining")?,
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            time_remaining: read_value::<f32>(
+                stream,
+                definition.get_entry("time_remaining"),
+                "time_remaining",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "time_remaining" => Ok(self.time_remaining.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayCaptureBroken",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayCaptureBlockedEvent {
     pub cp: u8,
     pub cp_name: MaybeUtf8String,
@@ -1856,17 +5145,48 @@ pub struct TeamPlayCaptureBlockedEvent {
 impl TeamPlayCaptureBlockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayCaptureBlockedEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            cp_name: read_value::<MaybeUtf8String>(stream, iter.next(), "cp_name")?,
-            blocker: read_value::<u8>(stream, iter.next(), "blocker")?,
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
-        })
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            cp_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cpname"),
+                "cp_name",
+            )?,
+            blocker: read_value::<u8>(stream, definition.get_entry("blocker"), "blocker")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "cpname" => Ok(self.cp_name.clone().into()),
+            "blocker" => Ok(self.blocker.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayCaptureBlocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayFlagEventEvent {
     pub player: u16,
     pub carrier: u16,
@@ -1877,18 +5197,46 @@ pub struct TeamPlayFlagEventEvent {
 impl TeamPlayFlagEventEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayFlagEventEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            carrier: read_value::<u16>(stream, iter.next(), "carrier")?,
-            event_type: read_value::<u16>(stream, iter.next(), "event_type")?,
-            home: read_value::<u8>(stream, iter.next(), "home")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-        })
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            carrier: read_value::<u16>(stream, definition.get_entry("carrier"), "carrier")?,
+            event_type: read_value::<u16>(stream, definition.get_entry("eventtype"), "event_type")?,
+            home: read_value::<u8>(stream, definition.get_entry("home"), "home")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "carrier" => Ok(self.carrier.clone().into()),
+            "eventtype" => Ok(self.event_type.clone().into()),
+            "home" => Ok(self.home.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayFlagEvent",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayWinPanelEvent {
     pub panel_style: u8,
     pub winning_team: u8,
@@ -1914,76 +5262,248 @@ pub struct TeamPlayWinPanelEvent {
 impl TeamPlayWinPanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayWinPanelEvent {
-            panel_style: read_value::<u8>(stream, iter.next(), "panel_style")?,
-            winning_team: read_value::<u8>(stream, iter.next(), "winning_team")?,
-            win_reason: read_value::<u8>(stream, iter.next(), "win_reason")?,
-            cappers: read_value::<MaybeUtf8String>(stream, iter.next(), "cappers")?,
-            flag_cap_limit: read_value::<u16>(stream, iter.next(), "flag_cap_limit")?,
-            blue_score: read_value::<u16>(stream, iter.next(), "blue_score")?,
-            red_score: read_value::<u16>(stream, iter.next(), "red_score")?,
-            blue_score_prev: read_value::<u16>(stream, iter.next(), "blue_score_prev")?,
-            red_score_prev: read_value::<u16>(stream, iter.next(), "red_score_prev")?,
-            round_complete: read_value::<u16>(stream, iter.next(), "round_complete")?,
-            rounds_remaining: read_value::<u16>(stream, iter.next(), "rounds_remaining")?,
-            player_1: read_value::<u16>(stream, iter.next(), "player_1")?,
-            player_1_points: read_value::<u16>(stream, iter.next(), "player_1_points")?,
-            player_2: read_value::<u16>(stream, iter.next(), "player_2")?,
-            player_2_points: read_value::<u16>(stream, iter.next(), "player_2_points")?,
-            player_3: read_value::<u16>(stream, iter.next(), "player_3")?,
-            player_3_points: read_value::<u16>(stream, iter.next(), "player_3_points")?,
-            kill_stream_player_1: read_value::<u16>(stream, iter.next(), "kill_stream_player_1")?,
-            kill_stream_player_1_count: read_value::<u16>(
+            panel_style: read_value::<u8>(
                 stream,
-                iter.next(),
-                "kill_stream_player_1_count",
+                definition.get_entry("panel_style"),
+                "panel_style",
             )?,
-            game_over: read_value::<u8>(stream, iter.next(), "game_over")?,
-        })
-    }
-}
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
-pub struct TeamPlayTeamBalancedPlayerEvent {
-    pub player: u16,
-    pub team: u8,
-}
-impl TeamPlayTeamBalancedPlayerEvent {
-    #[allow(unused_variables)]
-    fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
-        Ok(TeamPlayTeamBalancedPlayerEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-        })
-    }
-}
+            winning_team: read_value::<u8>(
+                stream,
+                definition.get_entry("winning_team"),
+                "winning_team",
+            )?,
+            win_reason: read_value::<u8>(stream, definition.get_entry("winreason"), "win_reason")?,
+            cappers: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cappers"),
+                "cappers",
+            )?,
+            flag_cap_limit: read_value::<u16>(
+                stream,
+                definition.get_entry("flagcaplimit"),
+                "flag_cap_limit",
+            )?,
+            blue_score: read_value::<u16>(
+                stream,
+                definition.get_entry("blue_score"),
+                "blue_score",
+            )?,
+            red_score: read_value::<u16>(stream, definition.get_entry("red_score"), "red_score")?,
+            blue_score_prev: read_value::<u16>(
+                stream,
+                definition.get_entry("blue_score_prev"),
+                "blue_score_prev",
+            )?,
+            red_score_prev: read_value::<u16>(
+                stream,
+                definition.get_entry("red_score_prev"),
+                "red_score_prev",
+            )?,
+            round_complete: read_value::<u16>(
+                stream,
+                definition.get_entry("round_complete"),
+                "round_complete",
+            )?,
+            rounds_remaining: read_value::<u16>(
+                stream,
+                definition.get_entry("rounds_remaining"),
+                "rounds_remaining",
+            )?,
+            player_1: read_value::<u16>(stream, definition.get_entry("player_1"), "player_1")?,
+            player_1_points: read_value::<u16>(
+                stream,
+                definition.get_entry("player_1_points"),
+                "player_1_points",
+            )?,
+            player_2: read_value::<u16>(stream, definition.get_entry("player_2"), "player_2")?,
+            player_2_points: read_value::<u16>(
+                stream,
+                definition.get_entry("player_2_points"),
+                "player_2_points",
+            )?,
+            player_3: read_value::<u16>(stream, definition.get_entry("player_3"), "player_3")?,
+            player_3_points: read_value::<u16>(
+                stream,
+                definition.get_entry("player_3_points"),
+                "player_3_points",
+            )?,
+            kill_stream_player_1: read_value::<u16>(
+                stream,
+                definition.get_entry("killstreak_player_1"),
+                "kill_stream_player_1",
+            )?,
+            kill_stream_player_1_count: read_value::<u16>(
+                stream,
+                definition.get_entry("killstreak_player_1_count"),
+                "kill_stream_player_1_count",
+            )?,
+            game_over: read_value::<u8>(stream, definition.get_entry("game_over"), "game_over")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "panel_style" => Ok(self.panel_style.clone().into()),
+            "winning_team" => Ok(self.winning_team.clone().into()),
+            "winreason" => Ok(self.win_reason.clone().into()),
+            "cappers" => Ok(self.cappers.clone().into()),
+            "flagcaplimit" => Ok(self.flag_cap_limit.clone().into()),
+            "blue_score" => Ok(self.blue_score.clone().into()),
+            "red_score" => Ok(self.red_score.clone().into()),
+            "blue_score_prev" => Ok(self.blue_score_prev.clone().into()),
+            "red_score_prev" => Ok(self.red_score_prev.clone().into()),
+            "round_complete" => Ok(self.round_complete.clone().into()),
+            "rounds_remaining" => Ok(self.rounds_remaining.clone().into()),
+            "player_1" => Ok(self.player_1.clone().into()),
+            "player_1_points" => Ok(self.player_1_points.clone().into()),
+            "player_2" => Ok(self.player_2.clone().into()),
+            "player_2_points" => Ok(self.player_2_points.clone().into()),
+            "player_3" => Ok(self.player_3.clone().into()),
+            "player_3_points" => Ok(self.player_3_points.clone().into()),
+            "killstreak_player_1" => Ok(self.kill_stream_player_1.clone().into()),
+            "killstreak_player_1_count" => Ok(self.kill_stream_player_1_count.clone().into()),
+            "game_over" => Ok(self.game_over.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayWinPanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+pub struct TeamPlayTeamBalancedPlayerEvent {
+    pub player: u16,
+    pub team: u8,
+}
+impl TeamPlayTeamBalancedPlayerEvent {
+    #[allow(unused_variables)]
+    fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
+        Ok(TeamPlayTeamBalancedPlayerEvent {
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayTeamBalancedPlayer",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlaySetupFinishedEvent {}
 impl TeamPlaySetupFinishedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamPlaySetupFinishedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlaySetupFinished",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayAlertEvent {
     pub alert_type: u16,
 }
 impl TeamPlayAlertEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayAlertEvent {
-            alert_type: read_value::<u16>(stream, iter.next(), "alert_type")?,
+            alert_type: read_value::<u16>(
+                stream,
+                definition.get_entry("alert_type"),
+                "alert_type",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "alert_type" => Ok(self.alert_type.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayAlert",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TrainingCompleteEvent {
     pub next_map: MaybeUtf8String,
     pub map: MaybeUtf8String,
@@ -1992,89 +5512,287 @@ pub struct TrainingCompleteEvent {
 impl TrainingCompleteEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TrainingCompleteEvent {
-            next_map: read_value::<MaybeUtf8String>(stream, iter.next(), "next_map")?,
-            map: read_value::<MaybeUtf8String>(stream, iter.next(), "map")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            next_map: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("next_map"),
+                "next_map",
+            )?,
+            map: read_value::<MaybeUtf8String>(stream, definition.get_entry("map"), "map")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "next_map" => Ok(self.next_map.clone().into()),
+            "map" => Ok(self.map.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TrainingComplete",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ShowFreezePanelEvent {
     pub killer: u16,
 }
 impl ShowFreezePanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ShowFreezePanelEvent {
-            killer: read_value::<u16>(stream, iter.next(), "killer")?,
+            killer: read_value::<u16>(stream, definition.get_entry("killer"), "killer")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "killer" => Ok(self.killer.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ShowFreezePanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HideFreezePanelEvent {}
 impl HideFreezePanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(HideFreezePanelEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HideFreezePanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FreezeCamStartedEvent {}
 impl FreezeCamStartedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(FreezeCamStartedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FreezeCamStarted",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerChangeTeamEvent {}
 impl LocalPlayerChangeTeamEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerChangeTeamEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerChangeTeam",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerScoreChangedEvent {
     pub score: u16,
 }
 impl LocalPlayerScoreChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(LocalPlayerScoreChangedEvent {
-            score: read_value::<u16>(stream, iter.next(), "score")?,
+            score: read_value::<u16>(stream, definition.get_entry("score"), "score")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "score" => Ok(self.score.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerScoreChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerChangeClassEvent {}
 impl LocalPlayerChangeClassEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerChangeClassEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerChangeClass",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerRespawnEvent {}
 impl LocalPlayerRespawnEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerRespawnEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerRespawn",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BuildingInfoChangedEvent {
     pub building_type: u8,
     pub object_mode: u8,
@@ -2083,30 +5801,88 @@ pub struct BuildingInfoChangedEvent {
 impl BuildingInfoChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BuildingInfoChangedEvent {
-            building_type: read_value::<u8>(stream, iter.next(), "building_type")?,
-            object_mode: read_value::<u8>(stream, iter.next(), "object_mode")?,
-            remove: read_value::<u8>(stream, iter.next(), "remove")?,
+            building_type: read_value::<u8>(
+                stream,
+                definition.get_entry("building_type"),
+                "building_type",
+            )?,
+            object_mode: read_value::<u8>(
+                stream,
+                definition.get_entry("object_mode"),
+                "object_mode",
+            )?,
+            remove: read_value::<u8>(stream, definition.get_entry("remove"), "remove")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "building_type" => Ok(self.building_type.clone().into()),
+            "object_mode" => Ok(self.object_mode.clone().into()),
+            "remove" => Ok(self.remove.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BuildingInfoChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerChangeDisguiseEvent {
     pub disguised: bool,
 }
 impl LocalPlayerChangeDisguiseEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(LocalPlayerChangeDisguiseEvent {
-            disguised: read_value::<bool>(stream, iter.next(), "disguised")?,
+            disguised: read_value::<bool>(stream, definition.get_entry("disguised"), "disguised")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "disguised" => Ok(self.disguised.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerChangeDisguise",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerAccountChangedEvent {
     pub old_value: u16,
     pub new_value: u16,
@@ -2114,24 +5890,73 @@ pub struct PlayerAccountChangedEvent {
 impl PlayerAccountChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerAccountChangedEvent {
-            old_value: read_value::<u16>(stream, iter.next(), "old_value")?,
-            new_value: read_value::<u16>(stream, iter.next(), "new_value")?,
+            old_value: read_value::<u16>(stream, definition.get_entry("old_value"), "old_value")?,
+            new_value: read_value::<u16>(stream, definition.get_entry("new_value"), "new_value")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "old_value" => Ok(self.old_value.clone().into()),
+            "new_value" => Ok(self.new_value.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerAccountChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SpyPdaResetEvent {}
 impl SpyPdaResetEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(SpyPdaResetEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SpyPdaReset",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FlagStatusUpdateEvent {
     pub user_id: u16,
     pub ent_index: u32,
@@ -2139,38 +5964,115 @@ pub struct FlagStatusUpdateEvent {
 impl FlagStatusUpdateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(FlagStatusUpdateEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            ent_index: read_value::<u32>(stream, iter.next(), "ent_index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            ent_index: read_value::<u32>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FlagStatusUpdate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerStatsUpdatedEvent {
     pub force_upload: bool,
 }
 impl PlayerStatsUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerStatsUpdatedEvent {
-            force_upload: read_value::<bool>(stream, iter.next(), "force_upload")?,
+            force_upload: read_value::<bool>(
+                stream,
+                definition.get_entry("forceupload"),
+                "force_upload",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "forceupload" => Ok(self.force_upload.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerStatsUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayingCommentaryEvent {}
 impl PlayingCommentaryEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PlayingCommentaryEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayingCommentary",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerChargeDeployedEvent {
     pub user_id: u16,
     pub target_id: u16,
@@ -2178,15 +6080,40 @@ pub struct PlayerChargeDeployedEvent {
 impl PlayerChargeDeployedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerChargeDeployedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            target_id: read_value::<u16>(stream, iter.next(), "target_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            target_id: read_value::<u16>(stream, definition.get_entry("targetid"), "target_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "targetid" => Ok(self.target_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerChargeDeployed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerBuiltObjectEvent {
     pub user_id: u16,
     pub object: u16,
@@ -2195,16 +6122,42 @@ pub struct PlayerBuiltObjectEvent {
 impl PlayerBuiltObjectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerBuiltObjectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object: read_value::<u16>(stream, iter.next(), "object")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object: read_value::<u16>(stream, definition.get_entry("object"), "object")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerBuiltObject",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerUpgradedObjectEvent {
     pub user_id: u16,
     pub object: u16,
@@ -2214,17 +6167,48 @@ pub struct PlayerUpgradedObjectEvent {
 impl PlayerUpgradedObjectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerUpgradedObjectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object: read_value::<u16>(stream, iter.next(), "object")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            is_builder: read_value::<bool>(stream, iter.next(), "is_builder")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object: read_value::<u16>(stream, definition.get_entry("object"), "object")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            is_builder: read_value::<bool>(
+                stream,
+                definition.get_entry("isbuilder"),
+                "is_builder",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            "isbuilder" => Ok(self.is_builder.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerUpgradedObject",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerCarryObjectEvent {
     pub user_id: u16,
     pub object: u16,
@@ -2233,16 +6217,42 @@ pub struct PlayerCarryObjectEvent {
 impl PlayerCarryObjectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerCarryObjectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object: read_value::<u16>(stream, iter.next(), "object")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object: read_value::<u16>(stream, definition.get_entry("object"), "object")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerCarryObject",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDropObjectEvent {
     pub user_id: u16,
     pub object: u16,
@@ -2251,16 +6261,42 @@ pub struct PlayerDropObjectEvent {
 impl PlayerDropObjectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDropObjectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object: read_value::<u16>(stream, iter.next(), "object")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object: read_value::<u16>(stream, definition.get_entry("object"), "object")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDropObject",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ObjectRemovedEvent {
     pub user_id: u16,
     pub object_type: u16,
@@ -2269,16 +6305,46 @@ pub struct ObjectRemovedEvent {
 impl ObjectRemovedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ObjectRemovedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object_type: read_value::<u16>(stream, iter.next(), "object_type")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object_type: read_value::<u16>(
+                stream,
+                definition.get_entry("objecttype"),
+                "object_type",
+            )?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "objecttype" => Ok(self.object_type.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ObjectRemoved",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ObjectDestroyedEvent {
     pub user_id: u16,
     pub attacker: u16,
@@ -2292,21 +6358,64 @@ pub struct ObjectDestroyedEvent {
 impl ObjectDestroyedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ObjectDestroyedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            object_type: read_value::<u16>(stream, iter.next(), "object_type")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            was_building: read_value::<bool>(stream, iter.next(), "was_building")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            object_type: read_value::<u16>(
+                stream,
+                definition.get_entry("objecttype"),
+                "object_type",
+            )?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            was_building: read_value::<bool>(
+                stream,
+                definition.get_entry("was_building"),
+                "was_building",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "objecttype" => Ok(self.object_type.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            "was_building" => Ok(self.was_building.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ObjectDestroyed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ObjectDetonatedEvent {
     pub user_id: u16,
     pub object_type: u16,
@@ -2315,16 +6424,46 @@ pub struct ObjectDetonatedEvent {
 impl ObjectDetonatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ObjectDetonatedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            object_type: read_value::<u16>(stream, iter.next(), "object_type")?,
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            object_type: read_value::<u16>(
+                stream,
+                definition.get_entry("objecttype"),
+                "object_type",
+            )?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "objecttype" => Ok(self.object_type.clone().into()),
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ObjectDetonated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct AchievementEarnedEvent {
     pub player: u8,
     pub achievement: u16,
@@ -2332,24 +6471,77 @@ pub struct AchievementEarnedEvent {
 impl AchievementEarnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(AchievementEarnedEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            achievement: read_value::<u16>(stream, iter.next(), "achievement")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            achievement: read_value::<u16>(
+                stream,
+                definition.get_entry("achievement"),
+                "achievement",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "achievement" => Ok(self.achievement.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "AchievementEarned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SpecTargetUpdatedEvent {}
 impl SpecTargetUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(SpecTargetUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SpecTargetUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TournamentStateUpdateEvent {
     pub user_id: u16,
     pub name_change: bool,
@@ -2359,63 +6551,198 @@ pub struct TournamentStateUpdateEvent {
 impl TournamentStateUpdateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TournamentStateUpdateEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            name_change: read_value::<bool>(stream, iter.next(), "name_change")?,
-            ready_state: read_value::<u16>(stream, iter.next(), "ready_state")?,
-            new_name: read_value::<MaybeUtf8String>(stream, iter.next(), "new_name")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            name_change: read_value::<bool>(
+                stream,
+                definition.get_entry("namechange"),
+                "name_change",
+            )?,
+            ready_state: read_value::<u16>(
+                stream,
+                definition.get_entry("readystate"),
+                "ready_state",
+            )?,
+            new_name: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("newname"),
+                "new_name",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "namechange" => Ok(self.name_change.clone().into()),
+            "readystate" => Ok(self.ready_state.clone().into()),
+            "newname" => Ok(self.new_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TournamentStateUpdate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TournamentEnableCountdownEvent {}
 impl TournamentEnableCountdownEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TournamentEnableCountdownEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TournamentEnableCountdown",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerCalledForMedicEvent {
     pub user_id: u16,
 }
 impl PlayerCalledForMedicEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerCalledForMedicEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerCalledForMedic",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerAskedForBallEvent {
     pub user_id: u16,
 }
 impl PlayerAskedForBallEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerAskedForBallEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerAskedForBall",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerBecameObserverEvent {}
 impl LocalPlayerBecameObserverEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerBecameObserverEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerBecameObserver",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerIgnitedInvEvent {
     pub pyro_ent_index: u8,
     pub victim_ent_index: u8,
@@ -2424,16 +6751,54 @@ pub struct PlayerIgnitedInvEvent {
 impl PlayerIgnitedInvEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerIgnitedInvEvent {
-            pyro_ent_index: read_value::<u8>(stream, iter.next(), "pyro_ent_index")?,
-            victim_ent_index: read_value::<u8>(stream, iter.next(), "victim_ent_index")?,
-            medic_ent_index: read_value::<u8>(stream, iter.next(), "medic_ent_index")?,
+            pyro_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("pyro_entindex"),
+                "pyro_ent_index",
+            )?,
+            victim_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            medic_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("medic_entindex"),
+                "medic_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "pyro_entindex" => Ok(self.pyro_ent_index.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "medic_entindex" => Ok(self.medic_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerIgnitedInv",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerIgnitedEvent {
     pub pyro_ent_index: u8,
     pub victim_ent_index: u8,
@@ -2442,16 +6807,50 @@ pub struct PlayerIgnitedEvent {
 impl PlayerIgnitedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerIgnitedEvent {
-            pyro_ent_index: read_value::<u8>(stream, iter.next(), "pyro_ent_index")?,
-            victim_ent_index: read_value::<u8>(stream, iter.next(), "victim_ent_index")?,
-            weapon_id: read_value::<u8>(stream, iter.next(), "weapon_id")?,
+            pyro_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("pyro_entindex"),
+                "pyro_ent_index",
+            )?,
+            victim_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            weapon_id: read_value::<u8>(stream, definition.get_entry("weaponid"), "weapon_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "pyro_entindex" => Ok(self.pyro_ent_index.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerIgnited",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerExtinguishedEvent {
     pub victim: u8,
     pub healer: u8,
@@ -2460,16 +6859,46 @@ pub struct PlayerExtinguishedEvent {
 impl PlayerExtinguishedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerExtinguishedEvent {
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
-            healer: read_value::<u8>(stream, iter.next(), "healer")?,
-            item_definition_index: read_value::<u16>(stream, iter.next(), "item_definition_index")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
+            healer: read_value::<u8>(stream, definition.get_entry("healer"), "healer")?,
+            item_definition_index: read_value::<u16>(
+                stream,
+                definition.get_entry("itemdefindex"),
+                "item_definition_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "victim" => Ok(self.victim.clone().into()),
+            "healer" => Ok(self.healer.clone().into()),
+            "itemdefindex" => Ok(self.item_definition_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerExtinguished",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerTeleportedEvent {
     pub user_id: u16,
     pub builder_id: u16,
@@ -2478,48 +6907,146 @@ pub struct PlayerTeleportedEvent {
 impl PlayerTeleportedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerTeleportedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            builder_id: read_value::<u16>(stream, iter.next(), "builder_id")?,
-            dist: read_value::<f32>(stream, iter.next(), "dist")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            builder_id: read_value::<u16>(stream, definition.get_entry("builderid"), "builder_id")?,
+            dist: read_value::<f32>(stream, definition.get_entry("dist"), "dist")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "builderid" => Ok(self.builder_id.clone().into()),
+            "dist" => Ok(self.dist.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerTeleported",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHealedMedicCallEvent {
     pub user_id: u16,
 }
 impl PlayerHealedMedicCallEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHealedMedicCallEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHealedMedicCall",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerChargeReadyEvent {}
 impl LocalPlayerChargeReadyEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerChargeReadyEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerChargeReady",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerWindDownEvent {}
 impl LocalPlayerWindDownEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerWindDownEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerWindDown",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerInvulnedEvent {
     pub user_id: u16,
     pub medic_user_id: u16,
@@ -2527,15 +7054,44 @@ pub struct PlayerInvulnedEvent {
 impl PlayerInvulnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerInvulnedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            medic_user_id: read_value::<u16>(stream, iter.next(), "medic_user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            medic_user_id: read_value::<u16>(
+                stream,
+                definition.get_entry("medic_userid"),
+                "medic_user_id",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "medic_userid" => Ok(self.medic_user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerInvulned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EscortSpeedEvent {
     pub team: u8,
     pub speed: u8,
@@ -2544,16 +7100,42 @@ pub struct EscortSpeedEvent {
 impl EscortSpeedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EscortSpeedEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            speed: read_value::<u8>(stream, iter.next(), "speed")?,
-            players: read_value::<u8>(stream, iter.next(), "players")?,
-        })
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            speed: read_value::<u8>(stream, definition.get_entry("speed"), "speed")?,
+            players: read_value::<u8>(stream, definition.get_entry("players"), "players")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "speed" => Ok(self.speed.clone().into()),
+            "players" => Ok(self.players.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EscortSpeed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EscortProgressEvent {
     pub team: u8,
     pub progress: f32,
@@ -2562,16 +7144,42 @@ pub struct EscortProgressEvent {
 impl EscortProgressEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EscortProgressEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            progress: read_value::<f32>(stream, iter.next(), "progress")?,
-            reset: read_value::<bool>(stream, iter.next(), "reset")?,
-        })
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            progress: read_value::<f32>(stream, definition.get_entry("progress"), "progress")?,
+            reset: read_value::<bool>(stream, definition.get_entry("reset"), "reset")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "progress" => Ok(self.progress.clone().into()),
+            "reset" => Ok(self.reset.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EscortProgress",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EscortRecedeEvent {
     pub team: u8,
     pub recede_time: f32,
@@ -2579,33 +7187,110 @@ pub struct EscortRecedeEvent {
 impl EscortRecedeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EscortRecedeEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            recede_time: read_value::<f32>(stream, iter.next(), "recede_time")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            recede_time: read_value::<f32>(
+                stream,
+                definition.get_entry("recedetime"),
+                "recede_time",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "recedetime" => Ok(self.recede_time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EscortRecede",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameUIActivatedEvent {}
 impl GameUIActivatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GameUIActivatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameUIActivated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GameUIHiddenEvent {}
 impl GameUIHiddenEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GameUIHiddenEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GameUIHidden",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerEscortScoreEvent {
     pub player: u8,
     pub points: u8,
@@ -2613,15 +7298,40 @@ pub struct PlayerEscortScoreEvent {
 impl PlayerEscortScoreEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerEscortScoreEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            points: read_value::<u8>(stream, iter.next(), "points")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            points: read_value::<u8>(stream, definition.get_entry("points"), "points")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "points" => Ok(self.points.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerEscortScore",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHealOnHitEvent {
     pub amount: u16,
     pub ent_index: u8,
@@ -2630,16 +7340,46 @@ pub struct PlayerHealOnHitEvent {
 impl PlayerHealOnHitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHealOnHitEvent {
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-            ent_index: read_value::<u8>(stream, iter.next(), "ent_index")?,
-            weapon_def_index: read_value::<u32>(stream, iter.next(), "weapon_def_index")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+            ent_index: read_value::<u8>(stream, definition.get_entry("entindex"), "ent_index")?,
+            weapon_def_index: read_value::<u32>(
+                stream,
+                definition.get_entry("weapon_def_index"),
+                "weapon_def_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "amount" => Ok(self.amount.clone().into()),
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "weapon_def_index" => Ok(self.weapon_def_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHealOnHit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerStealSandvichEvent {
     pub owner: u16,
     pub target: u16,
@@ -2647,43 +7387,116 @@ pub struct PlayerStealSandvichEvent {
 impl PlayerStealSandvichEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerStealSandvichEvent {
-            owner: read_value::<u16>(stream, iter.next(), "owner")?,
-            target: read_value::<u16>(stream, iter.next(), "target")?,
+            owner: read_value::<u16>(stream, definition.get_entry("owner"), "owner")?,
+            target: read_value::<u16>(stream, definition.get_entry("target"), "target")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "owner" => Ok(self.owner.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerStealSandvich",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ShowClassLayoutEvent {
     pub show: bool,
 }
 impl ShowClassLayoutEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ShowClassLayoutEvent {
-            show: read_value::<bool>(stream, iter.next(), "show")?,
+            show: read_value::<bool>(stream, definition.get_entry("show"), "show")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "show" => Ok(self.show.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ShowClassLayout",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ShowVsPanelEvent {
     pub show: bool,
 }
 impl ShowVsPanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ShowVsPanelEvent {
-            show: read_value::<bool>(stream, iter.next(), "show")?,
+            show: read_value::<bool>(stream, definition.get_entry("show"), "show")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "show" => Ok(self.show.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ShowVsPanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDamagedEvent {
     pub amount: u16,
     pub kind: u32,
@@ -2691,15 +7504,40 @@ pub struct PlayerDamagedEvent {
 impl PlayerDamagedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDamagedEvent {
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-            kind: read_value::<u32>(stream, iter.next(), "kind")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+            kind: read_value::<u32>(stream, definition.get_entry("type"), "kind")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "amount" => Ok(self.amount.clone().into()),
+            "type" => Ok(self.kind.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDamaged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ArenaPlayerNotificationEvent {
     pub player: u8,
     pub message: u8,
@@ -2707,15 +7545,40 @@ pub struct ArenaPlayerNotificationEvent {
 impl ArenaPlayerNotificationEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ArenaPlayerNotificationEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            message: read_value::<u8>(stream, iter.next(), "message")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            message: read_value::<u8>(stream, definition.get_entry("message"), "message")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "message" => Ok(self.message.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ArenaPlayerNotification",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ArenaMatchMaxStreakEvent {
     pub team: u8,
     pub streak: u8,
@@ -2723,24 +7586,73 @@ pub struct ArenaMatchMaxStreakEvent {
 impl ArenaMatchMaxStreakEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ArenaMatchMaxStreakEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            streak: read_value::<u8>(stream, iter.next(), "streak")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            streak: read_value::<u8>(stream, definition.get_entry("streak"), "streak")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "streak" => Ok(self.streak.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ArenaMatchMaxStreak",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ArenaRoundStartEvent {}
 impl ArenaRoundStartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ArenaRoundStartEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ArenaRoundStart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ArenaWinPanelEvent {
     pub panel_style: u8,
     pub winning_team: u8,
@@ -2786,53 +7698,244 @@ pub struct ArenaWinPanelEvent {
 impl ArenaWinPanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ArenaWinPanelEvent {
-            panel_style: read_value::<u8>(stream, iter.next(), "panel_style")?,
-            winning_team: read_value::<u8>(stream, iter.next(), "winning_team")?,
-            win_reason: read_value::<u8>(stream, iter.next(), "win_reason")?,
-            cappers: read_value::<MaybeUtf8String>(stream, iter.next(), "cappers")?,
-            flag_cap_limit: read_value::<u16>(stream, iter.next(), "flag_cap_limit")?,
-            blue_score: read_value::<u16>(stream, iter.next(), "blue_score")?,
-            red_score: read_value::<u16>(stream, iter.next(), "red_score")?,
-            blue_score_prev: read_value::<u16>(stream, iter.next(), "blue_score_prev")?,
-            red_score_prev: read_value::<u16>(stream, iter.next(), "red_score_prev")?,
-            round_complete: read_value::<u16>(stream, iter.next(), "round_complete")?,
-            player_1: read_value::<u16>(stream, iter.next(), "player_1")?,
-            player_1_damage: read_value::<u16>(stream, iter.next(), "player_1_damage")?,
-            player_1_healing: read_value::<u16>(stream, iter.next(), "player_1_healing")?,
-            player_1_lifetime: read_value::<u16>(stream, iter.next(), "player_1_lifetime")?,
-            player_1_kills: read_value::<u16>(stream, iter.next(), "player_1_kills")?,
-            player_2: read_value::<u16>(stream, iter.next(), "player_2")?,
-            player_2_damage: read_value::<u16>(stream, iter.next(), "player_2_damage")?,
-            player_2_healing: read_value::<u16>(stream, iter.next(), "player_2_healing")?,
-            player_2_lifetime: read_value::<u16>(stream, iter.next(), "player_2_lifetime")?,
-            player_2_kills: read_value::<u16>(stream, iter.next(), "player_2_kills")?,
-            player_3: read_value::<u16>(stream, iter.next(), "player_3")?,
-            player_3_damage: read_value::<u16>(stream, iter.next(), "player_3_damage")?,
-            player_3_healing: read_value::<u16>(stream, iter.next(), "player_3_healing")?,
-            player_3_lifetime: read_value::<u16>(stream, iter.next(), "player_3_lifetime")?,
-            player_3_kills: read_value::<u16>(stream, iter.next(), "player_3_kills")?,
-            player_4: read_value::<u16>(stream, iter.next(), "player_4")?,
-            player_4_damage: read_value::<u16>(stream, iter.next(), "player_4_damage")?,
-            player_4_healing: read_value::<u16>(stream, iter.next(), "player_4_healing")?,
-            player_4_lifetime: read_value::<u16>(stream, iter.next(), "player_4_lifetime")?,
-            player_4_kills: read_value::<u16>(stream, iter.next(), "player_4_kills")?,
-            player_5: read_value::<u16>(stream, iter.next(), "player_5")?,
-            player_5_damage: read_value::<u16>(stream, iter.next(), "player_5_damage")?,
-            player_5_healing: read_value::<u16>(stream, iter.next(), "player_5_healing")?,
-            player_5_lifetime: read_value::<u16>(stream, iter.next(), "player_5_lifetime")?,
-            player_5_kills: read_value::<u16>(stream, iter.next(), "player_5_kills")?,
-            player_6: read_value::<u16>(stream, iter.next(), "player_6")?,
-            player_6_damage: read_value::<u16>(stream, iter.next(), "player_6_damage")?,
-            player_6_healing: read_value::<u16>(stream, iter.next(), "player_6_healing")?,
-            player_6_lifetime: read_value::<u16>(stream, iter.next(), "player_6_lifetime")?,
-            player_6_kills: read_value::<u16>(stream, iter.next(), "player_6_kills")?,
-        })
-    }
-}
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+            panel_style: read_value::<u8>(
+                stream,
+                definition.get_entry("panel_style"),
+                "panel_style",
+            )?,
+            winning_team: read_value::<u8>(
+                stream,
+                definition.get_entry("winning_team"),
+                "winning_team",
+            )?,
+            win_reason: read_value::<u8>(stream, definition.get_entry("winreason"), "win_reason")?,
+            cappers: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("cappers"),
+                "cappers",
+            )?,
+            flag_cap_limit: read_value::<u16>(
+                stream,
+                definition.get_entry("flagcaplimit"),
+                "flag_cap_limit",
+            )?,
+            blue_score: read_value::<u16>(
+                stream,
+                definition.get_entry("blue_score"),
+                "blue_score",
+            )?,
+            red_score: read_value::<u16>(stream, definition.get_entry("red_score"), "red_score")?,
+            blue_score_prev: read_value::<u16>(
+                stream,
+                definition.get_entry("blue_score_prev"),
+                "blue_score_prev",
+            )?,
+            red_score_prev: read_value::<u16>(
+                stream,
+                definition.get_entry("red_score_prev"),
+                "red_score_prev",
+            )?,
+            round_complete: read_value::<u16>(
+                stream,
+                definition.get_entry("round_complete"),
+                "round_complete",
+            )?,
+            player_1: read_value::<u16>(stream, definition.get_entry("player_1"), "player_1")?,
+            player_1_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_1_damage"),
+                "player_1_damage",
+            )?,
+            player_1_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_1_healing"),
+                "player_1_healing",
+            )?,
+            player_1_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_1_lifetime"),
+                "player_1_lifetime",
+            )?,
+            player_1_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_1_kills"),
+                "player_1_kills",
+            )?,
+            player_2: read_value::<u16>(stream, definition.get_entry("player_2"), "player_2")?,
+            player_2_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_2_damage"),
+                "player_2_damage",
+            )?,
+            player_2_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_2_healing"),
+                "player_2_healing",
+            )?,
+            player_2_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_2_lifetime"),
+                "player_2_lifetime",
+            )?,
+            player_2_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_2_kills"),
+                "player_2_kills",
+            )?,
+            player_3: read_value::<u16>(stream, definition.get_entry("player_3"), "player_3")?,
+            player_3_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_3_damage"),
+                "player_3_damage",
+            )?,
+            player_3_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_3_healing"),
+                "player_3_healing",
+            )?,
+            player_3_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_3_lifetime"),
+                "player_3_lifetime",
+            )?,
+            player_3_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_3_kills"),
+                "player_3_kills",
+            )?,
+            player_4: read_value::<u16>(stream, definition.get_entry("player_4"), "player_4")?,
+            player_4_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_4_damage"),
+                "player_4_damage",
+            )?,
+            player_4_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_4_healing"),
+                "player_4_healing",
+            )?,
+            player_4_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_4_lifetime"),
+                "player_4_lifetime",
+            )?,
+            player_4_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_4_kills"),
+                "player_4_kills",
+            )?,
+            player_5: read_value::<u16>(stream, definition.get_entry("player_5"), "player_5")?,
+            player_5_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_5_damage"),
+                "player_5_damage",
+            )?,
+            player_5_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_5_healing"),
+                "player_5_healing",
+            )?,
+            player_5_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_5_lifetime"),
+                "player_5_lifetime",
+            )?,
+            player_5_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_5_kills"),
+                "player_5_kills",
+            )?,
+            player_6: read_value::<u16>(stream, definition.get_entry("player_6"), "player_6")?,
+            player_6_damage: read_value::<u16>(
+                stream,
+                definition.get_entry("player_6_damage"),
+                "player_6_damage",
+            )?,
+            player_6_healing: read_value::<u16>(
+                stream,
+                definition.get_entry("player_6_healing"),
+                "player_6_healing",
+            )?,
+            player_6_lifetime: read_value::<u16>(
+                stream,
+                definition.get_entry("player_6_lifetime"),
+                "player_6_lifetime",
+            )?,
+            player_6_kills: read_value::<u16>(
+                stream,
+                definition.get_entry("player_6_kills"),
+                "player_6_kills",
+            )?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "panel_style" => Ok(self.panel_style.clone().into()),
+            "winning_team" => Ok(self.winning_team.clone().into()),
+            "winreason" => Ok(self.win_reason.clone().into()),
+            "cappers" => Ok(self.cappers.clone().into()),
+            "flagcaplimit" => Ok(self.flag_cap_limit.clone().into()),
+            "blue_score" => Ok(self.blue_score.clone().into()),
+            "red_score" => Ok(self.red_score.clone().into()),
+            "blue_score_prev" => Ok(self.blue_score_prev.clone().into()),
+            "red_score_prev" => Ok(self.red_score_prev.clone().into()),
+            "round_complete" => Ok(self.round_complete.clone().into()),
+            "player_1" => Ok(self.player_1.clone().into()),
+            "player_1_damage" => Ok(self.player_1_damage.clone().into()),
+            "player_1_healing" => Ok(self.player_1_healing.clone().into()),
+            "player_1_lifetime" => Ok(self.player_1_lifetime.clone().into()),
+            "player_1_kills" => Ok(self.player_1_kills.clone().into()),
+            "player_2" => Ok(self.player_2.clone().into()),
+            "player_2_damage" => Ok(self.player_2_damage.clone().into()),
+            "player_2_healing" => Ok(self.player_2_healing.clone().into()),
+            "player_2_lifetime" => Ok(self.player_2_lifetime.clone().into()),
+            "player_2_kills" => Ok(self.player_2_kills.clone().into()),
+            "player_3" => Ok(self.player_3.clone().into()),
+            "player_3_damage" => Ok(self.player_3_damage.clone().into()),
+            "player_3_healing" => Ok(self.player_3_healing.clone().into()),
+            "player_3_lifetime" => Ok(self.player_3_lifetime.clone().into()),
+            "player_3_kills" => Ok(self.player_3_kills.clone().into()),
+            "player_4" => Ok(self.player_4.clone().into()),
+            "player_4_damage" => Ok(self.player_4_damage.clone().into()),
+            "player_4_healing" => Ok(self.player_4_healing.clone().into()),
+            "player_4_lifetime" => Ok(self.player_4_lifetime.clone().into()),
+            "player_4_kills" => Ok(self.player_4_kills.clone().into()),
+            "player_5" => Ok(self.player_5.clone().into()),
+            "player_5_damage" => Ok(self.player_5_damage.clone().into()),
+            "player_5_healing" => Ok(self.player_5_healing.clone().into()),
+            "player_5_lifetime" => Ok(self.player_5_lifetime.clone().into()),
+            "player_5_kills" => Ok(self.player_5_kills.clone().into()),
+            "player_6" => Ok(self.player_6.clone().into()),
+            "player_6_damage" => Ok(self.player_6_damage.clone().into()),
+            "player_6_healing" => Ok(self.player_6_healing.clone().into()),
+            "player_6_lifetime" => Ok(self.player_6_lifetime.clone().into()),
+            "player_6_kills" => Ok(self.player_6_kills.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ArenaWinPanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
+}
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PveWinPanelEvent {
     pub panel_style: u8,
     pub winning_team: u8,
@@ -2841,58 +7944,164 @@ pub struct PveWinPanelEvent {
 impl PveWinPanelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PveWinPanelEvent {
-            panel_style: read_value::<u8>(stream, iter.next(), "panel_style")?,
-            winning_team: read_value::<u8>(stream, iter.next(), "winning_team")?,
-            win_reason: read_value::<u8>(stream, iter.next(), "win_reason")?,
+            panel_style: read_value::<u8>(
+                stream,
+                definition.get_entry("panel_style"),
+                "panel_style",
+            )?,
+            winning_team: read_value::<u8>(
+                stream,
+                definition.get_entry("winning_team"),
+                "winning_team",
+            )?,
+            win_reason: read_value::<u8>(stream, definition.get_entry("winreason"), "win_reason")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "panel_style" => Ok(self.panel_style.clone().into()),
+            "winning_team" => Ok(self.winning_team.clone().into()),
+            "winreason" => Ok(self.win_reason.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PveWinPanel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct AirDashEvent {
     pub player: u8,
 }
 impl AirDashEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(AirDashEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "AirDash",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LandedEvent {
     pub player: u8,
 }
 impl LandedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(LandedEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "Landed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDamageDodgedEvent {
     pub damage: u16,
 }
 impl PlayerDamageDodgedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDamageDodgedEvent {
-            damage: read_value::<u16>(stream, iter.next(), "damage")?,
+            damage: read_value::<u16>(stream, definition.get_entry("damage"), "damage")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "damage" => Ok(self.damage.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDamageDodged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerStunnedEvent {
     pub stunner: u16,
     pub victim: u16,
@@ -2902,17 +8111,48 @@ pub struct PlayerStunnedEvent {
 impl PlayerStunnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerStunnedEvent {
-            stunner: read_value::<u16>(stream, iter.next(), "stunner")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
-            victim_capping: read_value::<bool>(stream, iter.next(), "victim_capping")?,
-            big_stun: read_value::<bool>(stream, iter.next(), "big_stun")?,
+            stunner: read_value::<u16>(stream, definition.get_entry("stunner"), "stunner")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
+            victim_capping: read_value::<bool>(
+                stream,
+                definition.get_entry("victim_capping"),
+                "victim_capping",
+            )?,
+            big_stun: read_value::<bool>(stream, definition.get_entry("big_stun"), "big_stun")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "stunner" => Ok(self.stunner.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            "victim_capping" => Ok(self.victim_capping.clone().into()),
+            "big_stun" => Ok(self.big_stun.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerStunned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ScoutGrandSlamEvent {
     pub scout_id: u16,
     pub target_id: u16,
@@ -2920,15 +8160,40 @@ pub struct ScoutGrandSlamEvent {
 impl ScoutGrandSlamEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ScoutGrandSlamEvent {
-            scout_id: read_value::<u16>(stream, iter.next(), "scout_id")?,
-            target_id: read_value::<u16>(stream, iter.next(), "target_id")?,
+            scout_id: read_value::<u16>(stream, definition.get_entry("scout_id"), "scout_id")?,
+            target_id: read_value::<u16>(stream, definition.get_entry("target_id"), "target_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "scout_id" => Ok(self.scout_id.clone().into()),
+            "target_id" => Ok(self.target_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ScoutGrandSlam",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ScoutSlamdollLandedEvent {
     pub target_index: u16,
     pub x: f32,
@@ -2938,17 +8203,48 @@ pub struct ScoutSlamdollLandedEvent {
 impl ScoutSlamdollLandedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ScoutSlamdollLandedEvent {
-            target_index: read_value::<u16>(stream, iter.next(), "target_index")?,
-            x: read_value::<f32>(stream, iter.next(), "x")?,
-            y: read_value::<f32>(stream, iter.next(), "y")?,
-            z: read_value::<f32>(stream, iter.next(), "z")?,
-        })
+            target_index: read_value::<u16>(
+                stream,
+                definition.get_entry("target_index"),
+                "target_index",
+            )?,
+            x: read_value::<f32>(stream, definition.get_entry("x"), "x")?,
+            y: read_value::<f32>(stream, definition.get_entry("y"), "y")?,
+            z: read_value::<f32>(stream, definition.get_entry("z"), "z")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "target_index" => Ok(self.target_index.clone().into()),
+            "x" => Ok(self.x.clone().into()),
+            "y" => Ok(self.y.clone().into()),
+            "z" => Ok(self.z.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ScoutSlamdollLanded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ArrowImpactEvent {
     pub attached_entity: u16,
     pub shooter: u16,
@@ -2965,24 +8261,94 @@ pub struct ArrowImpactEvent {
 impl ArrowImpactEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ArrowImpactEvent {
-            attached_entity: read_value::<u16>(stream, iter.next(), "attached_entity")?,
-            shooter: read_value::<u16>(stream, iter.next(), "shooter")?,
-            bone_index_attached: read_value::<u16>(stream, iter.next(), "bone_index_attached")?,
-            bone_position_x: read_value::<f32>(stream, iter.next(), "bone_position_x")?,
-            bone_position_y: read_value::<f32>(stream, iter.next(), "bone_position_y")?,
-            bone_position_z: read_value::<f32>(stream, iter.next(), "bone_position_z")?,
-            bone_angles_x: read_value::<f32>(stream, iter.next(), "bone_angles_x")?,
-            bone_angles_y: read_value::<f32>(stream, iter.next(), "bone_angles_y")?,
-            bone_angles_z: read_value::<f32>(stream, iter.next(), "bone_angles_z")?,
-            projectile_type: read_value::<u16>(stream, iter.next(), "projectile_type")?,
-            is_crit: read_value::<bool>(stream, iter.next(), "is_crit")?,
-        })
+            attached_entity: read_value::<u16>(
+                stream,
+                definition.get_entry("attachedEntity"),
+                "attached_entity",
+            )?,
+            shooter: read_value::<u16>(stream, definition.get_entry("shooter"), "shooter")?,
+            bone_index_attached: read_value::<u16>(
+                stream,
+                definition.get_entry("boneIndexAttached"),
+                "bone_index_attached",
+            )?,
+            bone_position_x: read_value::<f32>(
+                stream,
+                definition.get_entry("bonePositionX"),
+                "bone_position_x",
+            )?,
+            bone_position_y: read_value::<f32>(
+                stream,
+                definition.get_entry("bonePositionY"),
+                "bone_position_y",
+            )?,
+            bone_position_z: read_value::<f32>(
+                stream,
+                definition.get_entry("bonePositionZ"),
+                "bone_position_z",
+            )?,
+            bone_angles_x: read_value::<f32>(
+                stream,
+                definition.get_entry("boneAnglesX"),
+                "bone_angles_x",
+            )?,
+            bone_angles_y: read_value::<f32>(
+                stream,
+                definition.get_entry("boneAnglesY"),
+                "bone_angles_y",
+            )?,
+            bone_angles_z: read_value::<f32>(
+                stream,
+                definition.get_entry("boneAnglesZ"),
+                "bone_angles_z",
+            )?,
+            projectile_type: read_value::<u16>(
+                stream,
+                definition.get_entry("projectileType"),
+                "projectile_type",
+            )?,
+            is_crit: read_value::<bool>(stream, definition.get_entry("isCrit"), "is_crit")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attachedEntity" => Ok(self.attached_entity.clone().into()),
+            "shooter" => Ok(self.shooter.clone().into()),
+            "boneIndexAttached" => Ok(self.bone_index_attached.clone().into()),
+            "bonePositionX" => Ok(self.bone_position_x.clone().into()),
+            "bonePositionY" => Ok(self.bone_position_y.clone().into()),
+            "bonePositionZ" => Ok(self.bone_position_z.clone().into()),
+            "boneAnglesX" => Ok(self.bone_angles_x.clone().into()),
+            "boneAnglesY" => Ok(self.bone_angles_y.clone().into()),
+            "boneAnglesZ" => Ok(self.bone_angles_z.clone().into()),
+            "projectileType" => Ok(self.projectile_type.clone().into()),
+            "isCrit" => Ok(self.is_crit.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ArrowImpact",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerJaratedEvent {
     pub thrower_ent_index: u8,
     pub victim_ent_index: u8,
@@ -2990,15 +8356,48 @@ pub struct PlayerJaratedEvent {
 impl PlayerJaratedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerJaratedEvent {
-            thrower_ent_index: read_value::<u8>(stream, iter.next(), "thrower_ent_index")?,
-            victim_ent_index: read_value::<u8>(stream, iter.next(), "victim_ent_index")?,
+            thrower_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("thrower_entindex"),
+                "thrower_ent_index",
+            )?,
+            victim_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "thrower_entindex" => Ok(self.thrower_ent_index.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerJarated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerJaratedFadeEvent {
     pub thrower_ent_index: u8,
     pub victim_ent_index: u8,
@@ -3006,15 +8405,48 @@ pub struct PlayerJaratedFadeEvent {
 impl PlayerJaratedFadeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerJaratedFadeEvent {
-            thrower_ent_index: read_value::<u8>(stream, iter.next(), "thrower_ent_index")?,
-            victim_ent_index: read_value::<u8>(stream, iter.next(), "victim_ent_index")?,
+            thrower_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("thrower_entindex"),
+                "thrower_ent_index",
+            )?,
+            victim_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "thrower_entindex" => Ok(self.thrower_ent_index.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerJaratedFade",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerShieldBlockedEvent {
     pub attacker_ent_index: u8,
     pub blocker_ent_index: u8,
@@ -3022,43 +8454,124 @@ pub struct PlayerShieldBlockedEvent {
 impl PlayerShieldBlockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerShieldBlockedEvent {
-            attacker_ent_index: read_value::<u8>(stream, iter.next(), "attacker_ent_index")?,
-            blocker_ent_index: read_value::<u8>(stream, iter.next(), "blocker_ent_index")?,
+            attacker_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("attacker_entindex"),
+                "attacker_ent_index",
+            )?,
+            blocker_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("blocker_entindex"),
+                "blocker_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attacker_entindex" => Ok(self.attacker_ent_index.clone().into()),
+            "blocker_entindex" => Ok(self.blocker_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerShieldBlocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerPinnedEvent {
     pub pinned: u8,
 }
 impl PlayerPinnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerPinnedEvent {
-            pinned: read_value::<u8>(stream, iter.next(), "pinned")?,
+            pinned: read_value::<u8>(stream, definition.get_entry("pinned"), "pinned")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "pinned" => Ok(self.pinned.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerPinned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHealedByMedicEvent {
     pub medic: u8,
 }
 impl PlayerHealedByMedicEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHealedByMedicEvent {
-            medic: read_value::<u8>(stream, iter.next(), "medic")?,
+            medic: read_value::<u8>(stream, definition.get_entry("medic"), "medic")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "medic" => Ok(self.medic.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHealedByMedic",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerSappedObjectEvent {
     pub user_id: u16,
     pub owner_id: u16,
@@ -3068,17 +8581,44 @@ pub struct PlayerSappedObjectEvent {
 impl PlayerSappedObjectEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerSappedObjectEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            owner_id: read_value::<u16>(stream, iter.next(), "owner_id")?,
-            object: read_value::<u8>(stream, iter.next(), "object")?,
-            sapper_id: read_value::<u16>(stream, iter.next(), "sapper_id")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            owner_id: read_value::<u16>(stream, definition.get_entry("ownerid"), "owner_id")?,
+            object: read_value::<u8>(stream, definition.get_entry("object"), "object")?,
+            sapper_id: read_value::<u16>(stream, definition.get_entry("sapperid"), "sapper_id")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "ownerid" => Ok(self.owner_id.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            "sapperid" => Ok(self.sapper_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerSappedObject",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ItemFoundEvent {
     pub player: u8,
     pub quality: u8,
@@ -3091,20 +8631,50 @@ pub struct ItemFoundEvent {
 impl ItemFoundEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ItemFoundEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            quality: read_value::<u8>(stream, iter.next(), "quality")?,
-            method: read_value::<u8>(stream, iter.next(), "method")?,
-            item_def: read_value::<u32>(stream, iter.next(), "item_def")?,
-            is_strange: read_value::<u8>(stream, iter.next(), "is_strange")?,
-            is_unusual: read_value::<u8>(stream, iter.next(), "is_unusual")?,
-            wear: read_value::<f32>(stream, iter.next(), "wear")?,
-        })
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            quality: read_value::<u8>(stream, definition.get_entry("quality"), "quality")?,
+            method: read_value::<u8>(stream, definition.get_entry("method"), "method")?,
+            item_def: read_value::<u32>(stream, definition.get_entry("itemdef"), "item_def")?,
+            is_strange: read_value::<u8>(stream, definition.get_entry("isstrange"), "is_strange")?,
+            is_unusual: read_value::<u8>(stream, definition.get_entry("isunusual"), "is_unusual")?,
+            wear: read_value::<f32>(stream, definition.get_entry("wear"), "wear")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "quality" => Ok(self.quality.clone().into()),
+            "method" => Ok(self.method.clone().into()),
+            "itemdef" => Ok(self.item_def.clone().into()),
+            "isstrange" => Ok(self.is_strange.clone().into()),
+            "isunusual" => Ok(self.is_unusual.clone().into()),
+            "wear" => Ok(self.wear.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ItemFound",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ShowAnnotationEvent {
     pub world_pos_x: f32,
     pub world_pos_y: f32,
@@ -3124,55 +8694,184 @@ pub struct ShowAnnotationEvent {
 impl ShowAnnotationEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ShowAnnotationEvent {
-            world_pos_x: read_value::<f32>(stream, iter.next(), "world_pos_x")?,
-            world_pos_y: read_value::<f32>(stream, iter.next(), "world_pos_y")?,
-            world_pos_z: read_value::<f32>(stream, iter.next(), "world_pos_z")?,
-            world_normal_x: read_value::<f32>(stream, iter.next(), "world_normal_x")?,
-            world_normal_y: read_value::<f32>(stream, iter.next(), "world_normal_y")?,
-            world_normal_z: read_value::<f32>(stream, iter.next(), "world_normal_z")?,
-            id: read_value::<u32>(stream, iter.next(), "id")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
-            lifetime: read_value::<f32>(stream, iter.next(), "lifetime")?,
-            visibility_bit_field: read_value::<u32>(stream, iter.next(), "visibility_bit_field")?,
-            follow_ent_index: read_value::<u32>(stream, iter.next(), "follow_ent_index")?,
-            show_distance: read_value::<bool>(stream, iter.next(), "show_distance")?,
-            play_sound: read_value::<MaybeUtf8String>(stream, iter.next(), "play_sound")?,
-            show_effect: read_value::<bool>(stream, iter.next(), "show_effect")?,
+            world_pos_x: read_value::<f32>(
+                stream,
+                definition.get_entry("worldPosX"),
+                "world_pos_x",
+            )?,
+            world_pos_y: read_value::<f32>(
+                stream,
+                definition.get_entry("worldPosY"),
+                "world_pos_y",
+            )?,
+            world_pos_z: read_value::<f32>(
+                stream,
+                definition.get_entry("worldPosZ"),
+                "world_pos_z",
+            )?,
+            world_normal_x: read_value::<f32>(
+                stream,
+                definition.get_entry("worldNormalX"),
+                "world_normal_x",
+            )?,
+            world_normal_y: read_value::<f32>(
+                stream,
+                definition.get_entry("worldNormalY"),
+                "world_normal_y",
+            )?,
+            world_normal_z: read_value::<f32>(
+                stream,
+                definition.get_entry("worldNormalZ"),
+                "world_normal_z",
+            )?,
+            id: read_value::<u32>(stream, definition.get_entry("id"), "id")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
+            lifetime: read_value::<f32>(stream, definition.get_entry("lifetime"), "lifetime")?,
+            visibility_bit_field: read_value::<u32>(
+                stream,
+                definition.get_entry("visibilityBitfield"),
+                "visibility_bit_field",
+            )?,
+            follow_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("follow_entindex"),
+                "follow_ent_index",
+            )?,
+            show_distance: read_value::<bool>(
+                stream,
+                definition.get_entry("show_distance"),
+                "show_distance",
+            )?,
+            play_sound: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("play_sound"),
+                "play_sound",
+            )?,
+            show_effect: read_value::<bool>(
+                stream,
+                definition.get_entry("show_effect"),
+                "show_effect",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "worldPosX" => Ok(self.world_pos_x.clone().into()),
+            "worldPosY" => Ok(self.world_pos_y.clone().into()),
+            "worldPosZ" => Ok(self.world_pos_z.clone().into()),
+            "worldNormalX" => Ok(self.world_normal_x.clone().into()),
+            "worldNormalY" => Ok(self.world_normal_y.clone().into()),
+            "worldNormalZ" => Ok(self.world_normal_z.clone().into()),
+            "id" => Ok(self.id.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            "lifetime" => Ok(self.lifetime.clone().into()),
+            "visibilityBitfield" => Ok(self.visibility_bit_field.clone().into()),
+            "follow_entindex" => Ok(self.follow_ent_index.clone().into()),
+            "show_distance" => Ok(self.show_distance.clone().into()),
+            "play_sound" => Ok(self.play_sound.clone().into()),
+            "show_effect" => Ok(self.show_effect.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ShowAnnotation",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HideAnnotationEvent {
     pub id: u32,
 }
 impl HideAnnotationEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HideAnnotationEvent {
-            id: read_value::<u32>(stream, iter.next(), "id")?,
+            id: read_value::<u32>(stream, definition.get_entry("id"), "id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "id" => Ok(self.id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HideAnnotation",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PostInventoryApplicationEvent {
     pub user_id: u16,
 }
 impl PostInventoryApplicationEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PostInventoryApplicationEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PostInventoryApplication",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointUnlockUpdatedEvent {
     pub index: u16,
     pub time: f32,
@@ -3180,15 +8879,40 @@ pub struct ControlPointUnlockUpdatedEvent {
 impl ControlPointUnlockUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointUnlockUpdatedEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            time: read_value::<f32>(stream, iter.next(), "time")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            time: read_value::<f32>(stream, definition.get_entry("time"), "time")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "time" => Ok(self.time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointUnlockUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DeployBuffBannerEvent {
     pub buff_type: u8,
     pub buff_owner: u16,
@@ -3196,15 +8920,44 @@ pub struct DeployBuffBannerEvent {
 impl DeployBuffBannerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DeployBuffBannerEvent {
-            buff_type: read_value::<u8>(stream, iter.next(), "buff_type")?,
-            buff_owner: read_value::<u16>(stream, iter.next(), "buff_owner")?,
+            buff_type: read_value::<u8>(stream, definition.get_entry("buff_type"), "buff_type")?,
+            buff_owner: read_value::<u16>(
+                stream,
+                definition.get_entry("buff_owner"),
+                "buff_owner",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "buff_type" => Ok(self.buff_type.clone().into()),
+            "buff_owner" => Ok(self.buff_owner.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DeployBuffBanner",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerBuffEvent {
     pub user_id: u16,
     pub buff_owner: u16,
@@ -3213,16 +8966,46 @@ pub struct PlayerBuffEvent {
 impl PlayerBuffEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerBuffEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            buff_owner: read_value::<u16>(stream, iter.next(), "buff_owner")?,
-            buff_type: read_value::<u8>(stream, iter.next(), "buff_type")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            buff_owner: read_value::<u16>(
+                stream,
+                definition.get_entry("buff_owner"),
+                "buff_owner",
+            )?,
+            buff_type: read_value::<u8>(stream, definition.get_entry("buff_type"), "buff_type")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "buff_owner" => Ok(self.buff_owner.clone().into()),
+            "buff_type" => Ok(self.buff_type.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerBuff",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MedicDeathEvent {
     pub user_id: u16,
     pub attacker: u16,
@@ -3232,49 +9015,148 @@ pub struct MedicDeathEvent {
 impl MedicDeathEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MedicDeathEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            healing: read_value::<u16>(stream, iter.next(), "healing")?,
-            charged: read_value::<bool>(stream, iter.next(), "charged")?,
-        })
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            healing: read_value::<u16>(stream, definition.get_entry("healing"), "healing")?,
+            charged: read_value::<bool>(stream, definition.get_entry("charged"), "charged")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "healing" => Ok(self.healing.clone().into()),
+            "charged" => Ok(self.charged.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MedicDeath",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct OvertimeNagEvent {}
 impl OvertimeNagEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(OvertimeNagEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "OvertimeNag",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamsChangedEvent {}
 impl TeamsChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TeamsChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamsChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HalloweenPumpkinGrabEvent {
     pub user_id: u16,
 }
 impl HalloweenPumpkinGrabEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HalloweenPumpkinGrabEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HalloweenPumpkinGrab",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RocketJumpEvent {
     pub user_id: u16,
     pub play_sound: bool,
@@ -3282,29 +9164,82 @@ pub struct RocketJumpEvent {
 impl RocketJumpEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RocketJumpEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            play_sound: read_value::<bool>(stream, iter.next(), "play_sound")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            play_sound: read_value::<bool>(
+                stream,
+                definition.get_entry("playsound"),
+                "play_sound",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "playsound" => Ok(self.play_sound.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RocketJump",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RocketJumpLandedEvent {
     pub user_id: u16,
 }
 impl RocketJumpLandedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RocketJumpLandedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RocketJumpLanded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StickyJumpEvent {
     pub user_id: u16,
     pub play_sound: bool,
@@ -3312,29 +9247,82 @@ pub struct StickyJumpEvent {
 impl StickyJumpEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(StickyJumpEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            play_sound: read_value::<bool>(stream, iter.next(), "play_sound")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            play_sound: read_value::<bool>(
+                stream,
+                definition.get_entry("playsound"),
+                "play_sound",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "playsound" => Ok(self.play_sound.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "StickyJump",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StickyJumpLandedEvent {
     pub user_id: u16,
 }
 impl StickyJumpLandedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(StickyJumpLandedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "StickyJumpLanded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RocketPackLaunchEvent {
     pub user_id: u16,
     pub play_sound: bool,
@@ -3342,29 +9330,82 @@ pub struct RocketPackLaunchEvent {
 impl RocketPackLaunchEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RocketPackLaunchEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            play_sound: read_value::<bool>(stream, iter.next(), "play_sound")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            play_sound: read_value::<bool>(
+                stream,
+                definition.get_entry("playsound"),
+                "play_sound",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "playsound" => Ok(self.play_sound.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RocketPackLaunch",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RocketPackLandedEvent {
     pub user_id: u16,
 }
 impl RocketPackLandedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RocketPackLandedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RocketPackLanded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MedicDefendedEvent {
     pub user_id: u16,
     pub medic: u16,
@@ -3372,43 +9413,116 @@ pub struct MedicDefendedEvent {
 impl MedicDefendedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MedicDefendedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            medic: read_value::<u16>(stream, iter.next(), "medic")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            medic: read_value::<u16>(stream, definition.get_entry("medic"), "medic")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "medic" => Ok(self.medic.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MedicDefended",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerHealedEvent {
     pub amount: u16,
 }
 impl LocalPlayerHealedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(LocalPlayerHealedEvent {
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "amount" => Ok(self.amount.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerHealed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDestroyedPipeBombEvent {
     pub user_id: u16,
 }
 impl PlayerDestroyedPipeBombEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDestroyedPipeBombEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDestroyedPipeBomb",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ObjectDeflectedEvent {
     pub user_id: u16,
     pub owner_id: u16,
@@ -3418,49 +9532,152 @@ pub struct ObjectDeflectedEvent {
 impl ObjectDeflectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ObjectDeflectedEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            owner_id: read_value::<u16>(stream, iter.next(), "owner_id")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            object_ent_index: read_value::<u16>(stream, iter.next(), "object_ent_index")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            owner_id: read_value::<u16>(stream, definition.get_entry("ownerid"), "owner_id")?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            object_ent_index: read_value::<u16>(
+                stream,
+                definition.get_entry("object_entindex"),
+                "object_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "ownerid" => Ok(self.owner_id.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "object_entindex" => Ok(self.object_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ObjectDeflected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerMvpEvent {
     pub player: u16,
 }
 impl PlayerMvpEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerMvpEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerMvp",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RaidSpawnMobEvent {}
 impl RaidSpawnMobEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(RaidSpawnMobEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RaidSpawnMob",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RaidSpawnSquadEvent {}
 impl RaidSpawnSquadEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(RaidSpawnSquadEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RaidSpawnSquad",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct NavBlockedEvent {
     pub area: u32,
     pub blocked: bool,
@@ -3468,29 +9685,78 @@ pub struct NavBlockedEvent {
 impl NavBlockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(NavBlockedEvent {
-            area: read_value::<u32>(stream, iter.next(), "area")?,
-            blocked: read_value::<bool>(stream, iter.next(), "blocked")?,
+            area: read_value::<u32>(stream, definition.get_entry("area"), "area")?,
+            blocked: read_value::<bool>(stream, definition.get_entry("blocked"), "blocked")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "area" => Ok(self.area.clone().into()),
+            "blocked" => Ok(self.blocked.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "NavBlocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PathTrackPassedEvent {
     pub index: u16,
 }
 impl PathTrackPassedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PathTrackPassedEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PathTrackPassed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct NumCappersChangedEvent {
     pub index: u16,
     pub count: u8,
@@ -3498,24 +9764,73 @@ pub struct NumCappersChangedEvent {
 impl NumCappersChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(NumCappersChangedEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            count: read_value::<u8>(stream, iter.next(), "count")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            count: read_value::<u8>(stream, definition.get_entry("count"), "count")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "count" => Ok(self.count.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "NumCappersChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerRegenerateEvent {}
 impl PlayerRegenerateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PlayerRegenerateEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerRegenerate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct UpdateStatusItemEvent {
     pub index: u8,
     pub object: u8,
@@ -3523,56 +9838,181 @@ pub struct UpdateStatusItemEvent {
 impl UpdateStatusItemEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(UpdateStatusItemEvent {
-            index: read_value::<u8>(stream, iter.next(), "index")?,
-            object: read_value::<u8>(stream, iter.next(), "object")?,
+            index: read_value::<u8>(stream, definition.get_entry("index"), "index")?,
+            object: read_value::<u8>(stream, definition.get_entry("object"), "object")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "object" => Ok(self.object.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "UpdateStatusItem",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StatsResetRoundEvent {}
 impl StatsResetRoundEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(StatsResetRoundEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "StatsResetRound",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ScoreStatsAccumulatedUpdateEvent {}
 impl ScoreStatsAccumulatedUpdateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ScoreStatsAccumulatedUpdateEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ScoreStatsAccumulatedUpdate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ScoreStatsAccumulatedResetEvent {}
 impl ScoreStatsAccumulatedResetEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ScoreStatsAccumulatedResetEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ScoreStatsAccumulatedReset",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct AchievementEarnedLocalEvent {
     pub achievement: u16,
 }
 impl AchievementEarnedLocalEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(AchievementEarnedLocalEvent {
-            achievement: read_value::<u16>(stream, iter.next(), "achievement")?,
+            achievement: read_value::<u16>(
+                stream,
+                definition.get_entry("achievement"),
+                "achievement",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "achievement" => Ok(self.achievement.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "AchievementEarnedLocal",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHealedEvent {
     pub patient: u16,
     pub healer: u16,
@@ -3581,16 +10021,42 @@ pub struct PlayerHealedEvent {
 impl PlayerHealedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHealedEvent {
-            patient: read_value::<u16>(stream, iter.next(), "patient")?,
-            healer: read_value::<u16>(stream, iter.next(), "healer")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-        })
+            patient: read_value::<u16>(stream, definition.get_entry("patient"), "patient")?,
+            healer: read_value::<u16>(stream, definition.get_entry("healer"), "healer")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "patient" => Ok(self.patient.clone().into()),
+            "healer" => Ok(self.healer.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHealed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BuildingHealedEvent {
     pub building: u16,
     pub healer: u16,
@@ -3599,16 +10065,42 @@ pub struct BuildingHealedEvent {
 impl BuildingHealedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(BuildingHealedEvent {
-            building: read_value::<u16>(stream, iter.next(), "building")?,
-            healer: read_value::<u16>(stream, iter.next(), "healer")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-        })
+            building: read_value::<u16>(stream, definition.get_entry("building"), "building")?,
+            healer: read_value::<u16>(stream, definition.get_entry("healer"), "healer")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "building" => Ok(self.building.clone().into()),
+            "healer" => Ok(self.healer.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BuildingHealed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ItemPickupEvent {
     pub user_id: u16,
     pub item: MaybeUtf8String,
@@ -3616,15 +10108,40 @@ pub struct ItemPickupEvent {
 impl ItemPickupEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ItemPickupEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            item: read_value::<MaybeUtf8String>(stream, iter.next(), "item")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            item: read_value::<MaybeUtf8String>(stream, definition.get_entry("item"), "item")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "item" => Ok(self.item.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ItemPickup",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DuelStatusEvent {
     pub killer: u16,
     pub score_type: u16,
@@ -3636,19 +10153,60 @@ pub struct DuelStatusEvent {
 impl DuelStatusEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DuelStatusEvent {
-            killer: read_value::<u16>(stream, iter.next(), "killer")?,
-            score_type: read_value::<u16>(stream, iter.next(), "score_type")?,
-            initiator: read_value::<u16>(stream, iter.next(), "initiator")?,
-            target: read_value::<u16>(stream, iter.next(), "target")?,
-            initiator_score: read_value::<u16>(stream, iter.next(), "initiator_score")?,
-            target_score: read_value::<u16>(stream, iter.next(), "target_score")?,
+            killer: read_value::<u16>(stream, definition.get_entry("killer"), "killer")?,
+            score_type: read_value::<u16>(
+                stream,
+                definition.get_entry("score_type"),
+                "score_type",
+            )?,
+            initiator: read_value::<u16>(stream, definition.get_entry("initiator"), "initiator")?,
+            target: read_value::<u16>(stream, definition.get_entry("target"), "target")?,
+            initiator_score: read_value::<u16>(
+                stream,
+                definition.get_entry("initiator_score"),
+                "initiator_score",
+            )?,
+            target_score: read_value::<u16>(
+                stream,
+                definition.get_entry("target_score"),
+                "target_score",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "killer" => Ok(self.killer.clone().into()),
+            "score_type" => Ok(self.score_type.clone().into()),
+            "initiator" => Ok(self.initiator.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            "initiator_score" => Ok(self.initiator_score.clone().into()),
+            "target_score" => Ok(self.target_score.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DuelStatus",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FishNoticeEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -3668,35 +10226,104 @@ pub struct FishNoticeEvent {
 impl FishNoticeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(FishNoticeEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
-            stun_flags: read_value::<u16>(stream, iter.next(), "stun_flags")?,
-            death_flags: read_value::<u16>(stream, iter.next(), "death_flags")?,
-            silent_kill: read_value::<bool>(stream, iter.next(), "silent_kill")?,
+            stun_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("stun_flags"),
+                "stun_flags",
+            )?,
+            death_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("death_flags"),
+                "death_flags",
+            )?,
+            silent_kill: read_value::<bool>(
+                stream,
+                definition.get_entry("silent_kill"),
+                "silent_kill",
+            )?,
             assister_fallback: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("assister_fallback"),
                 "assister_fallback",
             )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            "stun_flags" => Ok(self.stun_flags.clone().into()),
+            "death_flags" => Ok(self.death_flags.clone().into()),
+            "silent_kill" => Ok(self.silent_kill.clone().into()),
+            "assister_fallback" => Ok(self.assister_fallback.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FishNotice",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FishNoticeArmEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -3716,35 +10343,104 @@ pub struct FishNoticeArmEvent {
 impl FishNoticeArmEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(FishNoticeArmEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
-            stun_flags: read_value::<u16>(stream, iter.next(), "stun_flags")?,
-            death_flags: read_value::<u16>(stream, iter.next(), "death_flags")?,
-            silent_kill: read_value::<bool>(stream, iter.next(), "silent_kill")?,
+            stun_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("stun_flags"),
+                "stun_flags",
+            )?,
+            death_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("death_flags"),
+                "death_flags",
+            )?,
+            silent_kill: read_value::<bool>(
+                stream,
+                definition.get_entry("silent_kill"),
+                "silent_kill",
+            )?,
             assister_fallback: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("assister_fallback"),
                 "assister_fallback",
             )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            "stun_flags" => Ok(self.stun_flags.clone().into()),
+            "death_flags" => Ok(self.death_flags.clone().into()),
+            "silent_kill" => Ok(self.silent_kill.clone().into()),
+            "assister_fallback" => Ok(self.assister_fallback.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FishNoticeArm",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SlapNoticeEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -3764,35 +10460,104 @@ pub struct SlapNoticeEvent {
 impl SlapNoticeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(SlapNoticeEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
-            stun_flags: read_value::<u16>(stream, iter.next(), "stun_flags")?,
-            death_flags: read_value::<u16>(stream, iter.next(), "death_flags")?,
-            silent_kill: read_value::<bool>(stream, iter.next(), "silent_kill")?,
+            stun_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("stun_flags"),
+                "stun_flags",
+            )?,
+            death_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("death_flags"),
+                "death_flags",
+            )?,
+            silent_kill: read_value::<bool>(
+                stream,
+                definition.get_entry("silent_kill"),
+                "silent_kill",
+            )?,
             assister_fallback: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("assister_fallback"),
                 "assister_fallback",
             )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            "stun_flags" => Ok(self.stun_flags.clone().into()),
+            "death_flags" => Ok(self.death_flags.clone().into()),
+            "silent_kill" => Ok(self.silent_kill.clone().into()),
+            "assister_fallback" => Ok(self.assister_fallback.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SlapNotice",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ThrowableHitEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -3813,82 +10578,248 @@ pub struct ThrowableHitEvent {
 impl ThrowableHitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ThrowableHitEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
-            stun_flags: read_value::<u16>(stream, iter.next(), "stun_flags")?,
-            death_flags: read_value::<u16>(stream, iter.next(), "death_flags")?,
-            silent_kill: read_value::<bool>(stream, iter.next(), "silent_kill")?,
+            stun_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("stun_flags"),
+                "stun_flags",
+            )?,
+            death_flags: read_value::<u16>(
+                stream,
+                definition.get_entry("death_flags"),
+                "death_flags",
+            )?,
+            silent_kill: read_value::<bool>(
+                stream,
+                definition.get_entry("silent_kill"),
+                "silent_kill",
+            )?,
             assister_fallback: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("assister_fallback"),
                 "assister_fallback",
             )?,
-            total_hits: read_value::<u16>(stream, iter.next(), "total_hits")?,
-        })
+            total_hits: read_value::<u16>(stream, definition.get_entry("totalhits"), "total_hits")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            "stun_flags" => Ok(self.stun_flags.clone().into()),
+            "death_flags" => Ok(self.death_flags.clone().into()),
+            "silent_kill" => Ok(self.silent_kill.clone().into()),
+            "assister_fallback" => Ok(self.assister_fallback.clone().into()),
+            "totalhits" => Ok(self.total_hits.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ThrowableHit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PumpkinLordSummonedEvent {}
 impl PumpkinLordSummonedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PumpkinLordSummonedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PumpkinLordSummoned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PumpkinLordKilledEvent {}
 impl PumpkinLordKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PumpkinLordKilledEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PumpkinLordKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusSummonedEvent {
     pub level: u16,
 }
 impl MerasmusSummonedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusSummonedEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusSummoned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusKilledEvent {
     pub level: u16,
 }
 impl MerasmusKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusKilledEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusEscapeWarningEvent {
     pub level: u16,
     pub time_remaining: u8,
@@ -3896,43 +10827,120 @@ pub struct MerasmusEscapeWarningEvent {
 impl MerasmusEscapeWarningEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusEscapeWarningEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
-            time_remaining: read_value::<u8>(stream, iter.next(), "time_remaining")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
+            time_remaining: read_value::<u8>(
+                stream,
+                definition.get_entry("time_remaining"),
+                "time_remaining",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            "time_remaining" => Ok(self.time_remaining.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusEscapeWarning",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusEscapedEvent {
     pub level: u16,
 }
 impl MerasmusEscapedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusEscapedEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusEscaped",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossSummonedEvent {
     pub level: u16,
 }
 impl EyeballBossSummonedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossSummonedEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossSummoned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossStunnedEvent {
     pub level: u16,
     pub player_ent_index: u8,
@@ -3940,29 +10948,82 @@ pub struct EyeballBossStunnedEvent {
 impl EyeballBossStunnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossStunnedEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
-            player_ent_index: read_value::<u8>(stream, iter.next(), "player_ent_index")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
+            player_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("player_entindex"),
+                "player_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            "player_entindex" => Ok(self.player_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossStunned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossKilledEvent {
     pub level: u16,
 }
 impl EyeballBossKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossKilledEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossKillerEvent {
     pub level: u16,
     pub player_ent_index: u8,
@@ -3970,15 +11031,44 @@ pub struct EyeballBossKillerEvent {
 impl EyeballBossKillerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossKillerEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
-            player_ent_index: read_value::<u8>(stream, iter.next(), "player_ent_index")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
+            player_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("player_entindex"),
+                "player_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            "player_entindex" => Ok(self.player_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossKiller",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossEscapeImminentEvent {
     pub level: u16,
     pub time_remaining: u8,
@@ -3986,29 +11076,82 @@ pub struct EyeballBossEscapeImminentEvent {
 impl EyeballBossEscapeImminentEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossEscapeImminentEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
-            time_remaining: read_value::<u8>(stream, iter.next(), "time_remaining")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
+            time_remaining: read_value::<u8>(
+                stream,
+                definition.get_entry("time_remaining"),
+                "time_remaining",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            "time_remaining" => Ok(self.time_remaining.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossEscapeImminent",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EyeballBossEscapedEvent {
     pub level: u16,
 }
 impl EyeballBossEscapedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EyeballBossEscapedEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EyeballBossEscaped",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct NpcHurtEvent {
     pub ent_index: u16,
     pub health: u16,
@@ -4021,20 +11164,58 @@ pub struct NpcHurtEvent {
 impl NpcHurtEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(NpcHurtEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
-            health: read_value::<u16>(stream, iter.next(), "health")?,
-            attacker_player: read_value::<u16>(stream, iter.next(), "attacker_player")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_amount: read_value::<u16>(stream, iter.next(), "damage_amount")?,
-            crit: read_value::<bool>(stream, iter.next(), "crit")?,
-            boss: read_value::<u16>(stream, iter.next(), "boss")?,
-        })
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
+            health: read_value::<u16>(stream, definition.get_entry("health"), "health")?,
+            attacker_player: read_value::<u16>(
+                stream,
+                definition.get_entry("attacker_player"),
+                "attacker_player",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_amount: read_value::<u16>(
+                stream,
+                definition.get_entry("damageamount"),
+                "damage_amount",
+            )?,
+            crit: read_value::<bool>(stream, definition.get_entry("crit"), "crit")?,
+            boss: read_value::<u16>(stream, definition.get_entry("boss"), "boss")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "health" => Ok(self.health.clone().into()),
+            "attacker_player" => Ok(self.attacker_player.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damageamount" => Ok(self.damage_amount.clone().into()),
+            "crit" => Ok(self.crit.clone().into()),
+            "boss" => Ok(self.boss.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "NpcHurt",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ControlPointTimerUpdatedEvent {
     pub index: u16,
     pub time: f32,
@@ -4042,43 +11223,116 @@ pub struct ControlPointTimerUpdatedEvent {
 impl ControlPointTimerUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ControlPointTimerUpdatedEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            time: read_value::<f32>(stream, iter.next(), "time")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            time: read_value::<f32>(stream, definition.get_entry("time"), "time")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "time" => Ok(self.time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ControlPointTimerUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHighFiveStartEvent {
     pub ent_index: u8,
 }
 impl PlayerHighFiveStartEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHighFiveStartEvent {
-            ent_index: read_value::<u8>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u8>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHighFiveStart",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHighFiveCancelEvent {
     pub ent_index: u8,
 }
 impl PlayerHighFiveCancelEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHighFiveCancelEvent {
-            ent_index: read_value::<u8>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u8>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHighFiveCancel",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerHighFiveSuccessEvent {
     pub initiator_ent_index: u8,
     pub partner_ent_index: u8,
@@ -4086,15 +11340,48 @@ pub struct PlayerHighFiveSuccessEvent {
 impl PlayerHighFiveSuccessEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerHighFiveSuccessEvent {
-            initiator_ent_index: read_value::<u8>(stream, iter.next(), "initiator_ent_index")?,
-            partner_ent_index: read_value::<u8>(stream, iter.next(), "partner_ent_index")?,
+            initiator_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("initiator_entindex"),
+                "initiator_ent_index",
+            )?,
+            partner_ent_index: read_value::<u8>(
+                stream,
+                definition.get_entry("partner_entindex"),
+                "partner_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "initiator_entindex" => Ok(self.initiator_ent_index.clone().into()),
+            "partner_entindex" => Ok(self.partner_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerHighFiveSuccess",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerBonusPointsEvent {
     pub points: u16,
     pub player_ent_index: u16,
@@ -4103,25 +11390,83 @@ pub struct PlayerBonusPointsEvent {
 impl PlayerBonusPointsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerBonusPointsEvent {
-            points: read_value::<u16>(stream, iter.next(), "points")?,
-            player_ent_index: read_value::<u16>(stream, iter.next(), "player_ent_index")?,
-            source_ent_index: read_value::<u16>(stream, iter.next(), "source_ent_index")?,
+            points: read_value::<u16>(stream, definition.get_entry("points"), "points")?,
+            player_ent_index: read_value::<u16>(
+                stream,
+                definition.get_entry("player_entindex"),
+                "player_ent_index",
+            )?,
+            source_ent_index: read_value::<u16>(
+                stream,
+                definition.get_entry("source_entindex"),
+                "source_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "points" => Ok(self.points.clone().into()),
+            "player_entindex" => Ok(self.player_ent_index.clone().into()),
+            "source_entindex" => Ok(self.source_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerBonusPoints",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerUpgradedEvent {}
 impl PlayerUpgradedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PlayerUpgradedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerUpgraded",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerBuybackEvent {
     pub player: u16,
     pub cost: u16,
@@ -4129,15 +11474,40 @@ pub struct PlayerBuybackEvent {
 impl PlayerBuybackEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerBuybackEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            cost: read_value::<u16>(stream, iter.next(), "cost")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            cost: read_value::<u16>(stream, definition.get_entry("cost"), "cost")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "cost" => Ok(self.cost.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerBuyback",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerUsedPowerUpBottleEvent {
     pub player: u16,
     pub kind: u16,
@@ -4146,30 +11516,80 @@ pub struct PlayerUsedPowerUpBottleEvent {
 impl PlayerUsedPowerUpBottleEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerUsedPowerUpBottleEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            kind: read_value::<u16>(stream, iter.next(), "kind")?,
-            time: read_value::<f32>(stream, iter.next(), "time")?,
-        })
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            kind: read_value::<u16>(stream, definition.get_entry("type"), "kind")?,
+            time: read_value::<f32>(stream, definition.get_entry("time"), "time")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "type" => Ok(self.kind.clone().into()),
+            "time" => Ok(self.time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerUsedPowerUpBottle",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ChristmasGiftGrabEvent {
     pub user_id: u16,
 }
 impl ChristmasGiftGrabEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ChristmasGiftGrabEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ChristmasGiftGrab",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerKilledAchievementZoneEvent {
     pub attacker: u16,
     pub victim: u16,
@@ -4178,66 +11598,216 @@ pub struct PlayerKilledAchievementZoneEvent {
 impl PlayerKilledAchievementZoneEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerKilledAchievementZoneEvent {
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
-            zone_id: read_value::<u16>(stream, iter.next(), "zone_id")?,
-        })
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
+            zone_id: read_value::<u16>(stream, definition.get_entry("zone_id"), "zone_id")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attacker" => Ok(self.attacker.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            "zone_id" => Ok(self.zone_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerKilledAchievementZone",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyUpdatedEvent {}
 impl PartyUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PartyUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyPrefChangedEvent {}
 impl PartyPrefChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PartyPrefChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyPrefChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyCriteriaChangedEvent {}
 impl PartyCriteriaChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PartyCriteriaChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyCriteriaChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyInvitesChangedEvent {}
 impl PartyInvitesChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PartyInvitesChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyInvitesChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyQueueStateChangedEvent {
     pub match_group: u16,
 }
 impl PartyQueueStateChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PartyQueueStateChangedEvent {
-            match_group: read_value::<u16>(stream, iter.next(), "match_group")?,
+            match_group: read_value::<u16>(
+                stream,
+                definition.get_entry("matchgroup"),
+                "match_group",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "matchgroup" => Ok(self.match_group.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyQueueStateChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyChatEvent {
     pub steam_id: MaybeUtf8String,
     pub text: MaybeUtf8String,
@@ -4246,62 +11816,196 @@ pub struct PartyChatEvent {
 impl PartyChatEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PartyChatEvent {
-            steam_id: read_value::<MaybeUtf8String>(stream, iter.next(), "steam_id")?,
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
-            kind: read_value::<u16>(stream, iter.next(), "kind")?,
+            steam_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("steamid"),
+                "steam_id",
+            )?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
+            kind: read_value::<u16>(stream, definition.get_entry("type"), "kind")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "steamid" => Ok(self.steam_id.clone().into()),
+            "text" => Ok(self.text.clone().into()),
+            "type" => Ok(self.kind.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyChat",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyMemberJoinEvent {
     pub steam_id: MaybeUtf8String,
 }
 impl PartyMemberJoinEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PartyMemberJoinEvent {
-            steam_id: read_value::<MaybeUtf8String>(stream, iter.next(), "steam_id")?,
+            steam_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("steamid"),
+                "steam_id",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "steamid" => Ok(self.steam_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyMemberJoin",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PartyMemberLeaveEvent {
     pub steam_id: MaybeUtf8String,
 }
 impl PartyMemberLeaveEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PartyMemberLeaveEvent {
-            steam_id: read_value::<MaybeUtf8String>(stream, iter.next(), "steam_id")?,
+            steam_id: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("steamid"),
+                "steam_id",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "steamid" => Ok(self.steam_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PartyMemberLeave",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MatchInvitesUpdatedEvent {}
 impl MatchInvitesUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MatchInvitesUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MatchInvitesUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LobbyUpdatedEvent {}
 impl LobbyUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LobbyUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LobbyUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmMissionUpdateEvent {
     pub class: u16,
     pub count: u16,
@@ -4309,130 +12013,395 @@ pub struct MvmMissionUpdateEvent {
 impl MvmMissionUpdateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmMissionUpdateEvent {
-            class: read_value::<u16>(stream, iter.next(), "class")?,
-            count: read_value::<u16>(stream, iter.next(), "count")?,
+            class: read_value::<u16>(stream, definition.get_entry("class"), "class")?,
+            count: read_value::<u16>(stream, definition.get_entry("count"), "count")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "class" => Ok(self.class.clone().into()),
+            "count" => Ok(self.count.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmMissionUpdate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RecalculateHolidaysEvent {}
 impl RecalculateHolidaysEvent {
     #[allow(unused_variables)]
-    fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        Ok(RecalculateHolidaysEvent {})
+    fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
+        Ok(RecalculateHolidaysEvent {})
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RecalculateHolidays",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerCurrencyChangedEvent {
     pub currency: u16,
 }
 impl PlayerCurrencyChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerCurrencyChangedEvent {
-            currency: read_value::<u16>(stream, iter.next(), "currency")?,
+            currency: read_value::<u16>(stream, definition.get_entry("currency"), "currency")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "currency" => Ok(self.currency.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerCurrencyChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DoomsdayRocketOpenEvent {
     pub team: u8,
 }
 impl DoomsdayRocketOpenEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DoomsdayRocketOpenEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DoomsdayRocketOpen",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RemoveNemesisRelationshipsEvent {
     pub player: u16,
 }
 impl RemoveNemesisRelationshipsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RemoveNemesisRelationshipsEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RemoveNemesisRelationships",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmCreditBonusWaveEvent {}
 impl MvmCreditBonusWaveEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmCreditBonusWaveEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmCreditBonusWave",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmCreditBonusAllEvent {}
 impl MvmCreditBonusAllEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmCreditBonusAllEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmCreditBonusAll",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmCreditBonusAllAdvancedEvent {}
 impl MvmCreditBonusAllAdvancedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmCreditBonusAllAdvancedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmCreditBonusAllAdvanced",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmQuickSentryUpgradeEvent {
     pub player: u16,
 }
 impl MvmQuickSentryUpgradeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmQuickSentryUpgradeEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmQuickSentryUpgrade",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmTankDestroyedByPlayersEvent {}
 impl MvmTankDestroyedByPlayersEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmTankDestroyedByPlayersEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmTankDestroyedByPlayers",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmKillRobotDeliveringBombEvent {
     pub player: u16,
 }
 impl MvmKillRobotDeliveringBombEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmKillRobotDeliveringBombEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmKillRobotDeliveringBomb",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmPickupCurrencyEvent {
     pub player: u16,
     pub currency: u16,
@@ -4440,29 +12409,78 @@ pub struct MvmPickupCurrencyEvent {
 impl MvmPickupCurrencyEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmPickupCurrencyEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            currency: read_value::<u16>(stream, iter.next(), "currency")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            currency: read_value::<u16>(stream, definition.get_entry("currency"), "currency")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "currency" => Ok(self.currency.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmPickupCurrency",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmBombCarrierKilledEvent {
     pub level: u16,
 }
 impl MvmBombCarrierKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmBombCarrierKilledEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmBombCarrierKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmSentryBusterDetonateEvent {
     pub player: u16,
     pub det_x: f32,
@@ -4472,45 +12490,120 @@ pub struct MvmSentryBusterDetonateEvent {
 impl MvmSentryBusterDetonateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmSentryBusterDetonateEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            det_x: read_value::<f32>(stream, iter.next(), "det_x")?,
-            det_y: read_value::<f32>(stream, iter.next(), "det_y")?,
-            det_z: read_value::<f32>(stream, iter.next(), "det_z")?,
-        })
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            det_x: read_value::<f32>(stream, definition.get_entry("det_x"), "det_x")?,
+            det_y: read_value::<f32>(stream, definition.get_entry("det_y"), "det_y")?,
+            det_z: read_value::<f32>(stream, definition.get_entry("det_z"), "det_z")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "det_x" => Ok(self.det_x.clone().into()),
+            "det_y" => Ok(self.det_y.clone().into()),
+            "det_z" => Ok(self.det_z.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmSentryBusterDetonate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmScoutMarkedForDeathEvent {
     pub player: u16,
 }
 impl MvmScoutMarkedForDeathEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmScoutMarkedForDeathEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmScoutMarkedForDeath",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmMedicPowerUpSharedEvent {
     pub player: u16,
 }
 impl MvmMedicPowerUpSharedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmMedicPowerUpSharedEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmMedicPowerUpShared",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmBeginWaveEvent {
     pub wave_index: u16,
     pub max_waves: u16,
@@ -4519,113 +12612,339 @@ pub struct MvmBeginWaveEvent {
 impl MvmBeginWaveEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmBeginWaveEvent {
-            wave_index: read_value::<u16>(stream, iter.next(), "wave_index")?,
-            max_waves: read_value::<u16>(stream, iter.next(), "max_waves")?,
-            advanced: read_value::<u16>(stream, iter.next(), "advanced")?,
+            wave_index: read_value::<u16>(
+                stream,
+                definition.get_entry("wave_index"),
+                "wave_index",
+            )?,
+            max_waves: read_value::<u16>(stream, definition.get_entry("max_waves"), "max_waves")?,
+            advanced: read_value::<u16>(stream, definition.get_entry("advanced"), "advanced")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "wave_index" => Ok(self.wave_index.clone().into()),
+            "max_waves" => Ok(self.max_waves.clone().into()),
+            "advanced" => Ok(self.advanced.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmBeginWave",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmWaveCompleteEvent {
     pub advanced: bool,
 }
 impl MvmWaveCompleteEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmWaveCompleteEvent {
-            advanced: read_value::<bool>(stream, iter.next(), "advanced")?,
+            advanced: read_value::<bool>(stream, definition.get_entry("advanced"), "advanced")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "advanced" => Ok(self.advanced.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmWaveComplete",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmMissionCompleteEvent {
     pub mission: MaybeUtf8String,
 }
 impl MvmMissionCompleteEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmMissionCompleteEvent {
-            mission: read_value::<MaybeUtf8String>(stream, iter.next(), "mission")?,
+            mission: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("mission"),
+                "mission",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "mission" => Ok(self.mission.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmMissionComplete",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmBombResetByPlayerEvent {
     pub player: u16,
 }
 impl MvmBombResetByPlayerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmBombResetByPlayerEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmBombResetByPlayer",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmBombAlarmTriggeredEvent {}
 impl MvmBombAlarmTriggeredEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmBombAlarmTriggeredEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmBombAlarmTriggered",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmBombDeployResetByPlayerEvent {
     pub player: u16,
 }
 impl MvmBombDeployResetByPlayerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmBombDeployResetByPlayerEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmBombDeployResetByPlayer",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmWaveFailedEvent {}
 impl MvmWaveFailedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmWaveFailedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmWaveFailed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmResetStatsEvent {}
 impl MvmResetStatsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmResetStatsEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmResetStats",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DamageResistedEvent {
     pub ent_index: u8,
 }
 impl DamageResistedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DamageResistedEvent {
-            ent_index: read_value::<u8>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u8>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DamageResisted",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RevivePlayerNotifyEvent {
     pub ent_index: u16,
     pub marker_ent_index: u16,
@@ -4633,57 +12952,158 @@ pub struct RevivePlayerNotifyEvent {
 impl RevivePlayerNotifyEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RevivePlayerNotifyEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
-            marker_ent_index: read_value::<u16>(stream, iter.next(), "marker_ent_index")?,
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
+            marker_ent_index: read_value::<u16>(
+                stream,
+                definition.get_entry("marker_entindex"),
+                "marker_ent_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "marker_entindex" => Ok(self.marker_ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RevivePlayerNotify",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RevivePlayerStoppedEvent {
     pub ent_index: u16,
 }
 impl RevivePlayerStoppedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RevivePlayerStoppedEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RevivePlayerStopped",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RevivePlayerCompleteEvent {
     pub ent_index: u16,
 }
 impl RevivePlayerCompleteEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RevivePlayerCompleteEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RevivePlayerComplete",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerTurnedToGhostEvent {
     pub user_id: u16,
 }
 impl PlayerTurnedToGhostEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerTurnedToGhostEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerTurnedToGhost",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MedigunShieldBlockedDamageEvent {
     pub user_id: u16,
     pub damage: f32,
@@ -4691,29 +13111,78 @@ pub struct MedigunShieldBlockedDamageEvent {
 impl MedigunShieldBlockedDamageEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MedigunShieldBlockedDamageEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            damage: read_value::<f32>(stream, iter.next(), "damage")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            damage: read_value::<f32>(stream, definition.get_entry("damage"), "damage")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "damage" => Ok(self.damage.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MedigunShieldBlockedDamage",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmAdvWaveCompleteNoGatesEvent {
     pub index: u16,
 }
 impl MvmAdvWaveCompleteNoGatesEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmAdvWaveCompleteNoGatesEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmAdvWaveCompleteNoGates",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmSniperHeadshotCurrencyEvent {
     pub user_id: u16,
     pub currency: u16,
@@ -4721,42 +13190,139 @@ pub struct MvmSniperHeadshotCurrencyEvent {
 impl MvmSniperHeadshotCurrencyEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmSniperHeadshotCurrencyEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            currency: read_value::<u16>(stream, iter.next(), "currency")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            currency: read_value::<u16>(stream, definition.get_entry("currency"), "currency")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "currency" => Ok(self.currency.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmSniperHeadshotCurrency",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmMannhattanPitEvent {}
 impl MvmMannhattanPitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmMannhattanPitEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmMannhattanPit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct FlagCarriedInDetectionZoneEvent {}
 impl FlagCarriedInDetectionZoneEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(FlagCarriedInDetectionZoneEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "FlagCarriedInDetectionZone",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmAdvWaveKilledStunRadioEvent {}
 impl MvmAdvWaveKilledStunRadioEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MvmAdvWaveKilledStunRadioEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmAdvWaveKilledStunRadio",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDirectHitStunEvent {
     pub attacker: u16,
     pub victim: u16,
@@ -4764,43 +13330,120 @@ pub struct PlayerDirectHitStunEvent {
 impl PlayerDirectHitStunEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDirectHitStunEvent {
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attacker" => Ok(self.attacker.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDirectHitStun",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MvmSentryBusterKilledEvent {
     pub sentry_buster: u16,
 }
 impl MvmSentryBusterKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MvmSentryBusterKilledEvent {
-            sentry_buster: read_value::<u16>(stream, iter.next(), "sentry_buster")?,
+            sentry_buster: read_value::<u16>(
+                stream,
+                definition.get_entry("sentry_buster"),
+                "sentry_buster",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "sentry_buster" => Ok(self.sentry_buster.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MvmSentryBusterKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct UpgradesFileChangedEvent {
     pub path: MaybeUtf8String,
 }
 impl UpgradesFileChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(UpgradesFileChangedEvent {
-            path: read_value::<MaybeUtf8String>(stream, iter.next(), "path")?,
+            path: read_value::<MaybeUtf8String>(stream, definition.get_entry("path"), "path")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "path" => Ok(self.path.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "UpgradesFileChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RdTeamPointsChangedEvent {
     pub points: u16,
     pub team: u8,
@@ -4809,25 +13452,75 @@ pub struct RdTeamPointsChangedEvent {
 impl RdTeamPointsChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RdTeamPointsChangedEvent {
-            points: read_value::<u16>(stream, iter.next(), "points")?,
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            method: read_value::<u8>(stream, iter.next(), "method")?,
-        })
+            points: read_value::<u16>(stream, definition.get_entry("points"), "points")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            method: read_value::<u8>(stream, definition.get_entry("method"), "method")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "points" => Ok(self.points.clone().into()),
+            "team" => Ok(self.team.clone().into()),
+            "method" => Ok(self.method.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RdTeamPointsChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RdRulesStateChangedEvent {}
 impl RdRulesStateChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(RdRulesStateChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RdRulesStateChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RdRobotKilledEvent {
     pub user_id: u16,
     pub victim_ent_index: u32,
@@ -4842,26 +13535,78 @@ pub struct RdRobotKilledEvent {
 impl RdRobotKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RdRobotKilledEvent {
-            user_id: read_value::<u16>(stream, iter.next(), "user_id")?,
-            victim_ent_index: read_value::<u32>(stream, iter.next(), "victim_ent_index")?,
-            inflictor_ent_index: read_value::<u32>(stream, iter.next(), "inflictor_ent_index")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
-            weapon: read_value::<MaybeUtf8String>(stream, iter.next(), "weapon")?,
-            weapon_id: read_value::<u16>(stream, iter.next(), "weapon_id")?,
-            damage_bits: read_value::<u32>(stream, iter.next(), "damage_bits")?,
-            custom_kill: read_value::<u16>(stream, iter.next(), "custom_kill")?,
+            user_id: read_value::<u16>(stream, definition.get_entry("userid"), "user_id")?,
+            victim_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("victim_entindex"),
+                "victim_ent_index",
+            )?,
+            inflictor_ent_index: read_value::<u32>(
+                stream,
+                definition.get_entry("inflictor_entindex"),
+                "inflictor_ent_index",
+            )?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("weapon"),
+                "weapon",
+            )?,
+            weapon_id: read_value::<u16>(stream, definition.get_entry("weaponid"), "weapon_id")?,
+            damage_bits: read_value::<u32>(
+                stream,
+                definition.get_entry("damagebits"),
+                "damage_bits",
+            )?,
+            custom_kill: read_value::<u16>(
+                stream,
+                definition.get_entry("customkill"),
+                "custom_kill",
+            )?,
             weapon_log_class_name: read_value::<MaybeUtf8String>(
                 stream,
-                iter.next(),
+                definition.get_entry("weapon_logclassname"),
                 "weapon_log_class_name",
             )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "userid" => Ok(self.user_id.clone().into()),
+            "victim_entindex" => Ok(self.victim_ent_index.clone().into()),
+            "inflictor_entindex" => Ok(self.inflictor_ent_index.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon" => Ok(self.weapon.clone().into()),
+            "weaponid" => Ok(self.weapon_id.clone().into()),
+            "damagebits" => Ok(self.damage_bits.clone().into()),
+            "customkill" => Ok(self.custom_kill.clone().into()),
+            "weapon_logclassname" => Ok(self.weapon_log_class_name.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RdRobotKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RdRobotImpactEvent {
     pub ent_index: u16,
     pub impulse_x: f32,
@@ -4871,73 +13616,196 @@ pub struct RdRobotImpactEvent {
 impl RdRobotImpactEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RdRobotImpactEvent {
-            ent_index: read_value::<u16>(stream, iter.next(), "ent_index")?,
-            impulse_x: read_value::<f32>(stream, iter.next(), "impulse_x")?,
-            impulse_y: read_value::<f32>(stream, iter.next(), "impulse_y")?,
-            impulse_z: read_value::<f32>(stream, iter.next(), "impulse_z")?,
-        })
+            ent_index: read_value::<u16>(stream, definition.get_entry("entindex"), "ent_index")?,
+            impulse_x: read_value::<f32>(stream, definition.get_entry("impulse_x"), "impulse_x")?,
+            impulse_y: read_value::<f32>(stream, definition.get_entry("impulse_y"), "impulse_y")?,
+            impulse_z: read_value::<f32>(stream, definition.get_entry("impulse_z"), "impulse_z")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "entindex" => Ok(self.ent_index.clone().into()),
+            "impulse_x" => Ok(self.impulse_x.clone().into()),
+            "impulse_y" => Ok(self.impulse_y.clone().into()),
+            "impulse_z" => Ok(self.impulse_z.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RdRobotImpact",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamPlayPreRoundTimeLeftEvent {
     pub time: u16,
 }
 impl TeamPlayPreRoundTimeLeftEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamPlayPreRoundTimeLeftEvent {
-            time: read_value::<u16>(stream, iter.next(), "time")?,
+            time: read_value::<u16>(stream, definition.get_entry("time"), "time")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "time" => Ok(self.time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamPlayPreRoundTimeLeft",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ParachuteDeployEvent {
     pub index: u16,
 }
 impl ParachuteDeployEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ParachuteDeployEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ParachuteDeploy",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ParachuteHolsterEvent {
     pub index: u16,
 }
 impl ParachuteHolsterEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ParachuteHolsterEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ParachuteHolster",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct KillRefillsMeterEvent {
     pub index: u16,
 }
 impl KillRefillsMeterEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(KillRefillsMeterEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "KillRefillsMeter",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RpsTauntEventEvent {
     pub winner: u16,
     pub winner_rps: u8,
@@ -4947,54 +13815,153 @@ pub struct RpsTauntEventEvent {
 impl RpsTauntEventEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RpsTauntEventEvent {
-            winner: read_value::<u16>(stream, iter.next(), "winner")?,
-            winner_rps: read_value::<u8>(stream, iter.next(), "winner_rps")?,
-            loser: read_value::<u16>(stream, iter.next(), "loser")?,
-            loser_rps: read_value::<u8>(stream, iter.next(), "loser_rps")?,
-        })
+            winner: read_value::<u16>(stream, definition.get_entry("winner"), "winner")?,
+            winner_rps: read_value::<u8>(stream, definition.get_entry("winner_rps"), "winner_rps")?,
+            loser: read_value::<u16>(stream, definition.get_entry("loser"), "loser")?,
+            loser_rps: read_value::<u8>(stream, definition.get_entry("loser_rps"), "loser_rps")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "winner" => Ok(self.winner.clone().into()),
+            "winner_rps" => Ok(self.winner_rps.clone().into()),
+            "loser" => Ok(self.loser.clone().into()),
+            "loser_rps" => Ok(self.loser_rps.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RpsTauntEvent",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CongaKillEvent {
     pub index: u16,
 }
 impl CongaKillEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CongaKillEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CongaKill",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerInitialSpawnEvent {
     pub index: u16,
 }
 impl PlayerInitialSpawnEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerInitialSpawnEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerInitialSpawn",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CompetitiveVictoryEvent {}
 impl CompetitiveVictoryEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(CompetitiveVictoryEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CompetitiveVictory",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CompetitiveStatsUpdateEvent {
     pub index: u16,
     pub kills_rank: u8,
@@ -5006,19 +13973,60 @@ pub struct CompetitiveStatsUpdateEvent {
 impl CompetitiveStatsUpdateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CompetitiveStatsUpdateEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            kills_rank: read_value::<u8>(stream, iter.next(), "kills_rank")?,
-            score_rank: read_value::<u8>(stream, iter.next(), "score_rank")?,
-            damage_rank: read_value::<u8>(stream, iter.next(), "damage_rank")?,
-            healing_rank: read_value::<u8>(stream, iter.next(), "healing_rank")?,
-            support_rank: read_value::<u8>(stream, iter.next(), "support_rank")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            kills_rank: read_value::<u8>(stream, definition.get_entry("kills_rank"), "kills_rank")?,
+            score_rank: read_value::<u8>(stream, definition.get_entry("score_rank"), "score_rank")?,
+            damage_rank: read_value::<u8>(
+                stream,
+                definition.get_entry("damage_rank"),
+                "damage_rank",
+            )?,
+            healing_rank: read_value::<u8>(
+                stream,
+                definition.get_entry("healing_rank"),
+                "healing_rank",
+            )?,
+            support_rank: read_value::<u8>(
+                stream,
+                definition.get_entry("support_rank"),
+                "support_rank",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "kills_rank" => Ok(self.kills_rank.clone().into()),
+            "score_rank" => Ok(self.score_rank.clone().into()),
+            "damage_rank" => Ok(self.damage_rank.clone().into()),
+            "healing_rank" => Ok(self.healing_rank.clone().into()),
+            "support_rank" => Ok(self.support_rank.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CompetitiveStatsUpdate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MiniGameWinEvent {
     pub team: u8,
     pub kind: u8,
@@ -5026,70 +14034,215 @@ pub struct MiniGameWinEvent {
 impl MiniGameWinEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MiniGameWinEvent {
-            team: read_value::<u8>(stream, iter.next(), "team")?,
-            kind: read_value::<u8>(stream, iter.next(), "kind")?,
+            team: read_value::<u8>(stream, definition.get_entry("team"), "team")?,
+            kind: read_value::<u8>(stream, definition.get_entry("type"), "kind")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "team" => Ok(self.team.clone().into()),
+            "type" => Ok(self.kind.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MiniGameWin",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SentryOnGoActiveEvent {
     pub index: u16,
 }
 impl SentryOnGoActiveEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(SentryOnGoActiveEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SentryOnGoActive",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DuckXpLevelUpEvent {
     pub level: u16,
 }
 impl DuckXpLevelUpEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DuckXpLevelUpEvent {
-            level: read_value::<u16>(stream, iter.next(), "level")?,
+            level: read_value::<u16>(stream, definition.get_entry("level"), "level")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "level" => Ok(self.level.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DuckXpLevelUp",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestLogOpenedEvent {}
 impl QuestLogOpenedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(QuestLogOpenedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestLogOpened",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SchemaUpdatedEvent {}
 impl SchemaUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(SchemaUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SchemaUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct LocalPlayerPickupWeaponEvent {}
 impl LocalPlayerPickupWeaponEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(LocalPlayerPickupWeaponEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "LocalPlayerPickupWeapon",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RdPlayerScorePointsEvent {
     pub player: u16,
     pub method: u16,
@@ -5098,30 +14251,80 @@ pub struct RdPlayerScorePointsEvent {
 impl RdPlayerScorePointsEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RdPlayerScorePointsEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            method: read_value::<u16>(stream, iter.next(), "method")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-        })
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            method: read_value::<u16>(stream, definition.get_entry("method"), "method")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "method" => Ok(self.method.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RdPlayerScorePoints",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DemomanDetStickiesEvent {
     pub player: u16,
 }
 impl DemomanDetStickiesEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DemomanDetStickiesEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DemomanDetStickies",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestObjectiveCompletedEvent {
     pub quest_item_id_low: u32,
     pub quest_item_id_hi: u32,
@@ -5131,17 +14334,60 @@ pub struct QuestObjectiveCompletedEvent {
 impl QuestObjectiveCompletedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(QuestObjectiveCompletedEvent {
-            quest_item_id_low: read_value::<u32>(stream, iter.next(), "quest_item_id_low")?,
-            quest_item_id_hi: read_value::<u32>(stream, iter.next(), "quest_item_id_hi")?,
-            quest_objective_id: read_value::<u32>(stream, iter.next(), "quest_objective_id")?,
-            scorer_user_id: read_value::<u16>(stream, iter.next(), "scorer_user_id")?,
+            quest_item_id_low: read_value::<u32>(
+                stream,
+                definition.get_entry("quest_item_id_low"),
+                "quest_item_id_low",
+            )?,
+            quest_item_id_hi: read_value::<u32>(
+                stream,
+                definition.get_entry("quest_item_id_hi"),
+                "quest_item_id_hi",
+            )?,
+            quest_objective_id: read_value::<u32>(
+                stream,
+                definition.get_entry("quest_objective_id"),
+                "quest_objective_id",
+            )?,
+            scorer_user_id: read_value::<u16>(
+                stream,
+                definition.get_entry("scorer_user_id"),
+                "scorer_user_id",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "quest_item_id_low" => Ok(self.quest_item_id_low.clone().into()),
+            "quest_item_id_hi" => Ok(self.quest_item_id_hi.clone().into()),
+            "quest_objective_id" => Ok(self.quest_objective_id.clone().into()),
+            "scorer_user_id" => Ok(self.scorer_user_id.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestObjectiveCompleted",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerScoreChangedEvent {
     pub player: u8,
     pub delta: u16,
@@ -5149,15 +14395,40 @@ pub struct PlayerScoreChangedEvent {
 impl PlayerScoreChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerScoreChangedEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            delta: read_value::<u16>(stream, iter.next(), "delta")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            delta: read_value::<u16>(stream, definition.get_entry("delta"), "delta")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "delta" => Ok(self.delta.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerScoreChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct KilledCappingPlayerEvent {
     pub cp: u8,
     pub killer: u8,
@@ -5167,17 +14438,44 @@ pub struct KilledCappingPlayerEvent {
 impl KilledCappingPlayerEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(KilledCappingPlayerEvent {
-            cp: read_value::<u8>(stream, iter.next(), "cp")?,
-            killer: read_value::<u8>(stream, iter.next(), "killer")?,
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
-            assister: read_value::<u8>(stream, iter.next(), "assister")?,
-        })
+            cp: read_value::<u8>(stream, definition.get_entry("cp"), "cp")?,
+            killer: read_value::<u8>(stream, definition.get_entry("killer"), "killer")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
+            assister: read_value::<u8>(stream, definition.get_entry("assister"), "assister")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "cp" => Ok(self.cp.clone().into()),
+            "killer" => Ok(self.killer.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "KilledCappingPlayer",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EnvironmentalDeathEvent {
     pub killer: u8,
     pub victim: u8,
@@ -5185,15 +14483,40 @@ pub struct EnvironmentalDeathEvent {
 impl EnvironmentalDeathEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EnvironmentalDeathEvent {
-            killer: read_value::<u8>(stream, iter.next(), "killer")?,
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
+            killer: read_value::<u8>(stream, definition.get_entry("killer"), "killer")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "killer" => Ok(self.killer.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EnvironmentalDeath",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ProjectileDirectHitEvent {
     pub attacker: u8,
     pub victim: u8,
@@ -5202,30 +14525,84 @@ pub struct ProjectileDirectHitEvent {
 impl ProjectileDirectHitEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ProjectileDirectHitEvent {
-            attacker: read_value::<u8>(stream, iter.next(), "attacker")?,
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
-            weapon_def_index: read_value::<u32>(stream, iter.next(), "weapon_def_index")?,
+            attacker: read_value::<u8>(stream, definition.get_entry("attacker"), "attacker")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
+            weapon_def_index: read_value::<u32>(
+                stream,
+                definition.get_entry("weapon_def_index"),
+                "weapon_def_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attacker" => Ok(self.attacker.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            "weapon_def_index" => Ok(self.weapon_def_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ProjectileDirectHit",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassGetEvent {
     pub owner: u16,
 }
 impl PassGetEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassGetEvent {
-            owner: read_value::<u16>(stream, iter.next(), "owner")?,
+            owner: read_value::<u16>(stream, definition.get_entry("owner"), "owner")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "owner" => Ok(self.owner.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassGet",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassScoreEvent {
     pub scorer: u16,
     pub assister: u16,
@@ -5234,16 +14611,42 @@ pub struct PassScoreEvent {
 impl PassScoreEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassScoreEvent {
-            scorer: read_value::<u16>(stream, iter.next(), "scorer")?,
-            assister: read_value::<u16>(stream, iter.next(), "assister")?,
-            points: read_value::<u8>(stream, iter.next(), "points")?,
-        })
+            scorer: read_value::<u16>(stream, definition.get_entry("scorer"), "scorer")?,
+            assister: read_value::<u16>(stream, definition.get_entry("assister"), "assister")?,
+            points: read_value::<u8>(stream, definition.get_entry("points"), "points")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "scorer" => Ok(self.scorer.clone().into()),
+            "assister" => Ok(self.assister.clone().into()),
+            "points" => Ok(self.points.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassScore",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassFreeEvent {
     pub owner: u16,
     pub attacker: u16,
@@ -5251,15 +14654,40 @@ pub struct PassFreeEvent {
 impl PassFreeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassFreeEvent {
-            owner: read_value::<u16>(stream, iter.next(), "owner")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
+            owner: read_value::<u16>(stream, definition.get_entry("owner"), "owner")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "owner" => Ok(self.owner.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassFree",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassPassCaughtEvent {
     pub passer: u16,
     pub catcher: u16,
@@ -5269,17 +14697,44 @@ pub struct PassPassCaughtEvent {
 impl PassPassCaughtEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassPassCaughtEvent {
-            passer: read_value::<u16>(stream, iter.next(), "passer")?,
-            catcher: read_value::<u16>(stream, iter.next(), "catcher")?,
-            dist: read_value::<f32>(stream, iter.next(), "dist")?,
-            duration: read_value::<f32>(stream, iter.next(), "duration")?,
-        })
+            passer: read_value::<u16>(stream, definition.get_entry("passer"), "passer")?,
+            catcher: read_value::<u16>(stream, definition.get_entry("catcher"), "catcher")?,
+            dist: read_value::<f32>(stream, definition.get_entry("dist"), "dist")?,
+            duration: read_value::<f32>(stream, definition.get_entry("duration"), "duration")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "passer" => Ok(self.passer.clone().into()),
+            "catcher" => Ok(self.catcher.clone().into()),
+            "dist" => Ok(self.dist.clone().into()),
+            "duration" => Ok(self.duration.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassPassCaught",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassBallStolenEvent {
     pub victim: u16,
     pub attacker: u16,
@@ -5287,15 +14742,40 @@ pub struct PassBallStolenEvent {
 impl PassBallStolenEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassBallStolenEvent {
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
-            attacker: read_value::<u16>(stream, iter.next(), "attacker")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
+            attacker: read_value::<u16>(stream, definition.get_entry("attacker"), "attacker")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "victim" => Ok(self.victim.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassBallStolen",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PassBallBlockedEvent {
     pub owner: u16,
     pub blocker: u16,
@@ -5303,15 +14783,40 @@ pub struct PassBallBlockedEvent {
 impl PassBallBlockedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PassBallBlockedEvent {
-            owner: read_value::<u16>(stream, iter.next(), "owner")?,
-            blocker: read_value::<u16>(stream, iter.next(), "blocker")?,
+            owner: read_value::<u16>(stream, definition.get_entry("owner"), "owner")?,
+            blocker: read_value::<u16>(stream, definition.get_entry("blocker"), "blocker")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "owner" => Ok(self.owner.clone().into()),
+            "blocker" => Ok(self.blocker.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PassBallBlocked",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DamagePreventedEvent {
     pub preventor: u16,
     pub victim: u16,
@@ -5321,17 +14826,44 @@ pub struct DamagePreventedEvent {
 impl DamagePreventedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DamagePreventedEvent {
-            preventor: read_value::<u16>(stream, iter.next(), "preventor")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-            condition: read_value::<u16>(stream, iter.next(), "condition")?,
-        })
+            preventor: read_value::<u16>(stream, definition.get_entry("preventor"), "preventor")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+            condition: read_value::<u16>(stream, definition.get_entry("condition"), "condition")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "preventor" => Ok(self.preventor.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            "condition" => Ok(self.condition.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DamagePrevented",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HalloweenBossKilledEvent {
     pub boss: u16,
     pub killer: u16,
@@ -5339,141 +14871,382 @@ pub struct HalloweenBossKilledEvent {
 impl HalloweenBossKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HalloweenBossKilledEvent {
-            boss: read_value::<u16>(stream, iter.next(), "boss")?,
-            killer: read_value::<u16>(stream, iter.next(), "killer")?,
+            boss: read_value::<u16>(stream, definition.get_entry("boss"), "boss")?,
+            killer: read_value::<u16>(stream, definition.get_entry("killer"), "killer")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "boss" => Ok(self.boss.clone().into()),
+            "killer" => Ok(self.killer.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HalloweenBossKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EscapedLootIslandEvent {
     pub player: u16,
 }
 impl EscapedLootIslandEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EscapedLootIslandEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EscapedLootIsland",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TaggedPlayerAsItEvent {
     pub player: u16,
 }
 impl TaggedPlayerAsItEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TaggedPlayerAsItEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TaggedPlayerAsIt",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusStunnedEvent {
     pub player: u16,
 }
 impl MerasmusStunnedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusStunnedEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusStunned",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MerasmusPropFoundEvent {
     pub player: u16,
 }
 impl MerasmusPropFoundEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MerasmusPropFoundEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MerasmusPropFound",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HalloweenSkeletonKilledEvent {
     pub player: u16,
 }
 impl HalloweenSkeletonKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HalloweenSkeletonKilledEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HalloweenSkeletonKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SkeletonKilledQuestEvent {
     pub player: u16,
 }
 impl SkeletonKilledQuestEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(SkeletonKilledQuestEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SkeletonKilledQuest",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SkeletonKingKilledQuestEvent {
     pub player: u16,
 }
 impl SkeletonKingKilledQuestEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(SkeletonKingKilledQuestEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SkeletonKingKilledQuest",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct EscapeHellEvent {
     pub player: u16,
 }
 impl EscapeHellEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(EscapeHellEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "EscapeHell",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CrossSpectralBridgeEvent {
     pub player: u16,
 }
 impl CrossSpectralBridgeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CrossSpectralBridgeEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CrossSpectralBridge",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MiniGameWonEvent {
     pub player: u16,
     pub game: u16,
@@ -5481,15 +15254,40 @@ pub struct MiniGameWonEvent {
 impl MiniGameWonEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(MiniGameWonEvent {
-            player: read_value::<u16>(stream, iter.next(), "player")?,
-            game: read_value::<u16>(stream, iter.next(), "game")?,
+            player: read_value::<u16>(stream, definition.get_entry("player"), "player")?,
+            game: read_value::<u16>(stream, definition.get_entry("game"), "game")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "game" => Ok(self.game.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MiniGameWon",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RespawnGhostEvent {
     pub reviver: u16,
     pub ghost: u16,
@@ -5497,15 +15295,40 @@ pub struct RespawnGhostEvent {
 impl RespawnGhostEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RespawnGhostEvent {
-            reviver: read_value::<u16>(stream, iter.next(), "reviver")?,
-            ghost: read_value::<u16>(stream, iter.next(), "ghost")?,
+            reviver: read_value::<u16>(stream, definition.get_entry("reviver"), "reviver")?,
+            ghost: read_value::<u16>(stream, definition.get_entry("ghost"), "ghost")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "reviver" => Ok(self.reviver.clone().into()),
+            "ghost" => Ok(self.ghost.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RespawnGhost",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct KillInHellEvent {
     pub killer: u16,
     pub victim: u16,
@@ -5513,43 +15336,116 @@ pub struct KillInHellEvent {
 impl KillInHellEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(KillInHellEvent {
-            killer: read_value::<u16>(stream, iter.next(), "killer")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
+            killer: read_value::<u16>(stream, definition.get_entry("killer"), "killer")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "killer" => Ok(self.killer.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "KillInHell",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HalloweenDuckCollectedEvent {
     pub collector: u16,
 }
 impl HalloweenDuckCollectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HalloweenDuckCollectedEvent {
-            collector: read_value::<u16>(stream, iter.next(), "collector")?,
+            collector: read_value::<u16>(stream, definition.get_entry("collector"), "collector")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "collector" => Ok(self.collector.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HalloweenDuckCollected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct SpecialScoreEvent {
     pub player: u8,
 }
 impl SpecialScoreEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(SpecialScoreEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "SpecialScore",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TeamLeaderKilledEvent {
     pub killer: u8,
     pub victim: u8,
@@ -5557,15 +15453,40 @@ pub struct TeamLeaderKilledEvent {
 impl TeamLeaderKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(TeamLeaderKilledEvent {
-            killer: read_value::<u8>(stream, iter.next(), "killer")?,
-            victim: read_value::<u8>(stream, iter.next(), "victim")?,
+            killer: read_value::<u8>(stream, definition.get_entry("killer"), "killer")?,
+            victim: read_value::<u8>(stream, definition.get_entry("victim"), "victim")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "killer" => Ok(self.killer.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TeamLeaderKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HalloweenSoulCollectedEvent {
     pub intended_target: u8,
     pub collecting_player: u8,
@@ -5574,25 +15495,83 @@ pub struct HalloweenSoulCollectedEvent {
 impl HalloweenSoulCollectedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HalloweenSoulCollectedEvent {
-            intended_target: read_value::<u8>(stream, iter.next(), "intended_target")?,
-            collecting_player: read_value::<u8>(stream, iter.next(), "collecting_player")?,
-            soul_count: read_value::<u8>(stream, iter.next(), "soul_count")?,
+            intended_target: read_value::<u8>(
+                stream,
+                definition.get_entry("intended_target"),
+                "intended_target",
+            )?,
+            collecting_player: read_value::<u8>(
+                stream,
+                definition.get_entry("collecting_player"),
+                "collecting_player",
+            )?,
+            soul_count: read_value::<u8>(stream, definition.get_entry("soul_count"), "soul_count")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "intended_target" => Ok(self.intended_target.clone().into()),
+            "collecting_player" => Ok(self.collecting_player.clone().into()),
+            "soul_count" => Ok(self.soul_count.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HalloweenSoulCollected",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RecalculateTruceEvent {}
 impl RecalculateTruceEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(RecalculateTruceEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RecalculateTruce",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DeadRingerCheatDeathEvent {
     pub spy: u8,
     pub attacker: u8,
@@ -5600,15 +15579,40 @@ pub struct DeadRingerCheatDeathEvent {
 impl DeadRingerCheatDeathEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DeadRingerCheatDeathEvent {
-            spy: read_value::<u8>(stream, iter.next(), "spy")?,
-            attacker: read_value::<u8>(stream, iter.next(), "attacker")?,
+            spy: read_value::<u8>(stream, definition.get_entry("spy"), "spy")?,
+            attacker: read_value::<u8>(stream, definition.get_entry("attacker"), "attacker")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "spy" => Ok(self.spy.clone().into()),
+            "attacker" => Ok(self.attacker.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DeadRingerCheatDeath",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CrossbowHealEvent {
     pub healer: u8,
     pub target: u8,
@@ -5617,16 +15621,42 @@ pub struct CrossbowHealEvent {
 impl CrossbowHealEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CrossbowHealEvent {
-            healer: read_value::<u8>(stream, iter.next(), "healer")?,
-            target: read_value::<u8>(stream, iter.next(), "target")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-        })
+            healer: read_value::<u8>(stream, definition.get_entry("healer"), "healer")?,
+            target: read_value::<u8>(stream, definition.get_entry("target"), "target")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "healer" => Ok(self.healer.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CrossbowHeal",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DamageMitigatedEvent {
     pub mitigator: u8,
     pub damaged: u8,
@@ -5636,17 +15666,48 @@ pub struct DamageMitigatedEvent {
 impl DamageMitigatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DamageMitigatedEvent {
-            mitigator: read_value::<u8>(stream, iter.next(), "mitigator")?,
-            damaged: read_value::<u8>(stream, iter.next(), "damaged")?,
-            amount: read_value::<u16>(stream, iter.next(), "amount")?,
-            item_definition_index: read_value::<u16>(stream, iter.next(), "item_definition_index")?,
+            mitigator: read_value::<u8>(stream, definition.get_entry("mitigator"), "mitigator")?,
+            damaged: read_value::<u8>(stream, definition.get_entry("damaged"), "damaged")?,
+            amount: read_value::<u16>(stream, definition.get_entry("amount"), "amount")?,
+            item_definition_index: read_value::<u16>(
+                stream,
+                definition.get_entry("itemdefindex"),
+                "item_definition_index",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "mitigator" => Ok(self.mitigator.clone().into()),
+            "damaged" => Ok(self.damaged.clone().into()),
+            "amount" => Ok(self.amount.clone().into()),
+            "itemdefindex" => Ok(self.item_definition_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DamageMitigated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PayloadPushedEvent {
     pub pusher: u8,
     pub distance: u16,
@@ -5654,29 +15715,78 @@ pub struct PayloadPushedEvent {
 impl PayloadPushedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PayloadPushedEvent {
-            pusher: read_value::<u8>(stream, iter.next(), "pusher")?,
-            distance: read_value::<u16>(stream, iter.next(), "distance")?,
+            pusher: read_value::<u8>(stream, definition.get_entry("pusher"), "pusher")?,
+            distance: read_value::<u16>(stream, definition.get_entry("distance"), "distance")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "pusher" => Ok(self.pusher.clone().into()),
+            "distance" => Ok(self.distance.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PayloadPushed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerAbandonedMatchEvent {
     pub game_over: bool,
 }
 impl PlayerAbandonedMatchEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerAbandonedMatchEvent {
-            game_over: read_value::<bool>(stream, iter.next(), "game_over")?,
+            game_over: read_value::<bool>(stream, definition.get_entry("game_over"), "game_over")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "game_over" => Ok(self.game_over.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerAbandonedMatch",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ClDrawlineEvent {
     pub player: u8,
     pub panel: u8,
@@ -5687,195 +15797,655 @@ pub struct ClDrawlineEvent {
 impl ClDrawlineEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ClDrawlineEvent {
-            player: read_value::<u8>(stream, iter.next(), "player")?,
-            panel: read_value::<u8>(stream, iter.next(), "panel")?,
-            line: read_value::<u8>(stream, iter.next(), "line")?,
-            x: read_value::<f32>(stream, iter.next(), "x")?,
-            y: read_value::<f32>(stream, iter.next(), "y")?,
-        })
+            player: read_value::<u8>(stream, definition.get_entry("player"), "player")?,
+            panel: read_value::<u8>(stream, definition.get_entry("panel"), "panel")?,
+            line: read_value::<u8>(stream, definition.get_entry("line"), "line")?,
+            x: read_value::<f32>(stream, definition.get_entry("x"), "x")?,
+            y: read_value::<f32>(stream, definition.get_entry("y"), "y")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "player" => Ok(self.player.clone().into()),
+            "panel" => Ok(self.panel.clone().into()),
+            "line" => Ok(self.line.clone().into()),
+            "x" => Ok(self.x.clone().into()),
+            "y" => Ok(self.y.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ClDrawline",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RestartTimerTimeEvent {
     pub time: u8,
 }
 impl RestartTimerTimeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RestartTimerTimeEvent {
-            time: read_value::<u8>(stream, iter.next(), "time")?,
+            time: read_value::<u8>(stream, definition.get_entry("time"), "time")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "time" => Ok(self.time.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RestartTimerTime",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct WinLimitChangedEvent {}
 impl WinLimitChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(WinLimitChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "WinLimitChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct WinPanelShowScoresEvent {}
 impl WinPanelShowScoresEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(WinPanelShowScoresEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "WinPanelShowScores",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct TopStreamsRequestFinishedEvent {}
 impl TopStreamsRequestFinishedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(TopStreamsRequestFinishedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "TopStreamsRequestFinished",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CompetitiveStateChangedEvent {}
 impl CompetitiveStateChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(CompetitiveStateChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CompetitiveStateChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GlobalWarDataUpdatedEvent {}
 impl GlobalWarDataUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(GlobalWarDataUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GlobalWarDataUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct StopWatchChangedEvent {}
 impl StopWatchChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(StopWatchChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "StopWatchChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DsStopEvent {}
 impl DsStopEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(DsStopEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DsStop",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct DsScreenshotEvent {
     pub delay: f32,
 }
 impl DsScreenshotEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(DsScreenshotEvent {
-            delay: read_value::<f32>(stream, iter.next(), "delay")?,
+            delay: read_value::<f32>(stream, definition.get_entry("delay"), "delay")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "delay" => Ok(self.delay.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "DsScreenshot",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ShowMatchSummaryEvent {}
 impl ShowMatchSummaryEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ShowMatchSummaryEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ShowMatchSummary",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ExperienceChangedEvent {}
 impl ExperienceChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ExperienceChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ExperienceChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct BeginXpLerpEvent {}
 impl BeginXpLerpEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(BeginXpLerpEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "BeginXpLerp",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MatchmakerStatsUpdatedEvent {}
 impl MatchmakerStatsUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MatchmakerStatsUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MatchmakerStatsUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RematchVotePeriodOverEvent {
     pub success: bool,
 }
 impl RematchVotePeriodOverEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(RematchVotePeriodOverEvent {
-            success: read_value::<bool>(stream, iter.next(), "success")?,
+            success: read_value::<bool>(stream, definition.get_entry("success"), "success")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "success" => Ok(self.success.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RematchVotePeriodOver",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct RematchFailedToCreateEvent {}
 impl RematchFailedToCreateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(RematchFailedToCreateEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "RematchFailedToCreate",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerRematchChangeEvent {}
 impl PlayerRematchChangeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PlayerRematchChangeEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerRematchChange",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PingUpdatedEvent {}
 impl PingUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(PingUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PingUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MMStatsUpdatedEvent {}
 impl MMStatsUpdatedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MMStatsUpdatedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MMStatsUpdated",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerNextMapVoteChangeEvent {
     pub map_index: u8,
     pub vote: u8,
@@ -5883,24 +16453,73 @@ pub struct PlayerNextMapVoteChangeEvent {
 impl PlayerNextMapVoteChangeEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerNextMapVoteChangeEvent {
-            map_index: read_value::<u8>(stream, iter.next(), "map_index")?,
-            vote: read_value::<u8>(stream, iter.next(), "vote")?,
+            map_index: read_value::<u8>(stream, definition.get_entry("map_index"), "map_index")?,
+            vote: read_value::<u8>(stream, definition.get_entry("vote"), "vote")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "map_index" => Ok(self.map_index.clone().into()),
+            "vote" => Ok(self.vote.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerNextMapVoteChange",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct VoteMapsChangedEvent {}
 impl VoteMapsChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(VoteMapsChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "VoteMapsChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ProtoDefChangedEvent {
     pub kind: u8,
     pub definition_index: u32,
@@ -5911,18 +16530,54 @@ pub struct ProtoDefChangedEvent {
 impl ProtoDefChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ProtoDefChangedEvent {
-            kind: read_value::<u8>(stream, iter.next(), "kind")?,
-            definition_index: read_value::<u32>(stream, iter.next(), "definition_index")?,
-            created: read_value::<bool>(stream, iter.next(), "created")?,
-            deleted: read_value::<bool>(stream, iter.next(), "deleted")?,
-            erase_history: read_value::<bool>(stream, iter.next(), "erase_history")?,
+            kind: read_value::<u8>(stream, definition.get_entry("type"), "kind")?,
+            definition_index: read_value::<u32>(
+                stream,
+                definition.get_entry("defindex"),
+                "definition_index",
+            )?,
+            created: read_value::<bool>(stream, definition.get_entry("created"), "created")?,
+            deleted: read_value::<bool>(stream, definition.get_entry("deleted"), "deleted")?,
+            erase_history: read_value::<bool>(
+                stream,
+                definition.get_entry("erase_history"),
+                "erase_history",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "type" => Ok(self.kind.clone().into()),
+            "defindex" => Ok(self.definition_index.clone().into()),
+            "created" => Ok(self.created.clone().into()),
+            "deleted" => Ok(self.deleted.clone().into()),
+            "erase_history" => Ok(self.erase_history.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ProtoDefChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerDominationEvent {
     pub dominator: u16,
     pub dominated: u16,
@@ -5931,16 +16586,46 @@ pub struct PlayerDominationEvent {
 impl PlayerDominationEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerDominationEvent {
-            dominator: read_value::<u16>(stream, iter.next(), "dominator")?,
-            dominated: read_value::<u16>(stream, iter.next(), "dominated")?,
-            dominations: read_value::<u16>(stream, iter.next(), "dominations")?,
+            dominator: read_value::<u16>(stream, definition.get_entry("dominator"), "dominator")?,
+            dominated: read_value::<u16>(stream, definition.get_entry("dominated"), "dominated")?,
+            dominations: read_value::<u16>(
+                stream,
+                definition.get_entry("dominations"),
+                "dominations",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "dominator" => Ok(self.dominator.clone().into()),
+            "dominated" => Ok(self.dominated.clone().into()),
+            "dominations" => Ok(self.dominations.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerDomination",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PlayerRocketPackPushedEvent {
     pub pusher: u16,
     pub pushed: u16,
@@ -5948,15 +16633,40 @@ pub struct PlayerRocketPackPushedEvent {
 impl PlayerRocketPackPushedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(PlayerRocketPackPushedEvent {
-            pusher: read_value::<u16>(stream, iter.next(), "pusher")?,
-            pushed: read_value::<u16>(stream, iter.next(), "pushed")?,
+            pusher: read_value::<u16>(stream, definition.get_entry("pusher"), "pusher")?,
+            pushed: read_value::<u16>(stream, definition.get_entry("pushed"), "pushed")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "pusher" => Ok(self.pusher.clone().into()),
+            "pushed" => Ok(self.pushed.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "PlayerRocketPackPushed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestRequestEvent {
     pub request: u32,
     pub msg: MaybeUtf8String,
@@ -5964,15 +16674,40 @@ pub struct QuestRequestEvent {
 impl QuestRequestEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(QuestRequestEvent {
-            request: read_value::<u32>(stream, iter.next(), "request")?,
-            msg: read_value::<MaybeUtf8String>(stream, iter.next(), "msg")?,
+            request: read_value::<u32>(stream, definition.get_entry("request"), "request")?,
+            msg: read_value::<MaybeUtf8String>(stream, definition.get_entry("msg"), "msg")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "request" => Ok(self.request.clone().into()),
+            "msg" => Ok(self.msg.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestRequest",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestResponseEvent {
     pub request: u32,
     pub success: bool,
@@ -5981,16 +16716,42 @@ pub struct QuestResponseEvent {
 impl QuestResponseEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(QuestResponseEvent {
-            request: read_value::<u32>(stream, iter.next(), "request")?,
-            success: read_value::<bool>(stream, iter.next(), "success")?,
-            msg: read_value::<MaybeUtf8String>(stream, iter.next(), "msg")?,
-        })
+            request: read_value::<u32>(stream, definition.get_entry("request"), "request")?,
+            success: read_value::<bool>(stream, definition.get_entry("success"), "success")?,
+            msg: read_value::<MaybeUtf8String>(stream, definition.get_entry("msg"), "msg")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "request" => Ok(self.request.clone().into()),
+            "success" => Ok(self.success.clone().into()),
+            "msg" => Ok(self.msg.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestResponse",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestProgressEvent {
     pub owner: u16,
     pub scorer: u16,
@@ -6001,22 +16762,50 @@ pub struct QuestProgressEvent {
 impl QuestProgressEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(QuestProgressEvent {
-            owner: read_value::<u16>(stream, iter.next(), "owner")?,
-            scorer: read_value::<u16>(stream, iter.next(), "scorer")?,
-            kind: read_value::<u8>(stream, iter.next(), "kind")?,
-            completed: read_value::<bool>(stream, iter.next(), "completed")?,
+            owner: read_value::<u16>(stream, definition.get_entry("owner"), "owner")?,
+            scorer: read_value::<u16>(stream, definition.get_entry("scorer"), "scorer")?,
+            kind: read_value::<u8>(stream, definition.get_entry("type"), "kind")?,
+            completed: read_value::<bool>(stream, definition.get_entry("completed"), "completed")?,
             quest_definition_index: read_value::<u32>(
                 stream,
-                iter.next(),
+                definition.get_entry("quest_defindex"),
                 "quest_definition_index",
             )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "owner" => Ok(self.owner.clone().into()),
+            "scorer" => Ok(self.scorer.clone().into()),
+            "type" => Ok(self.kind.clone().into()),
+            "completed" => Ok(self.completed.clone().into()),
+            "quest_defindex" => Ok(self.quest_definition_index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestProgress",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ProjectileRemovedEvent {
     pub attacker: u8,
     pub weapon_def_index: u32,
@@ -6026,26 +16815,85 @@ pub struct ProjectileRemovedEvent {
 impl ProjectileRemovedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ProjectileRemovedEvent {
-            attacker: read_value::<u8>(stream, iter.next(), "attacker")?,
-            weapon_def_index: read_value::<u32>(stream, iter.next(), "weapon_def_index")?,
-            num_hit: read_value::<u8>(stream, iter.next(), "num_hit")?,
-            num_direct_hit: read_value::<u8>(stream, iter.next(), "num_direct_hit")?,
+            attacker: read_value::<u8>(stream, definition.get_entry("attacker"), "attacker")?,
+            weapon_def_index: read_value::<u32>(
+                stream,
+                definition.get_entry("weapon_def_index"),
+                "weapon_def_index",
+            )?,
+            num_hit: read_value::<u8>(stream, definition.get_entry("num_hit"), "num_hit")?,
+            num_direct_hit: read_value::<u8>(
+                stream,
+                definition.get_entry("num_direct_hit"),
+                "num_direct_hit",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "attacker" => Ok(self.attacker.clone().into()),
+            "weapon_def_index" => Ok(self.weapon_def_index.clone().into()),
+            "num_hit" => Ok(self.num_hit.clone().into()),
+            "num_direct_hit" => Ok(self.num_direct_hit.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ProjectileRemoved",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestMapDataChangedEvent {}
 impl QuestMapDataChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(QuestMapDataChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestMapDataChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct GasDousedPlayerIgnitedEvent {
     pub igniter: u16,
     pub douser: u16,
@@ -6054,39 +16902,113 @@ pub struct GasDousedPlayerIgnitedEvent {
 impl GasDousedPlayerIgnitedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(GasDousedPlayerIgnitedEvent {
-            igniter: read_value::<u16>(stream, iter.next(), "igniter")?,
-            douser: read_value::<u16>(stream, iter.next(), "douser")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
-        })
+            igniter: read_value::<u16>(stream, definition.get_entry("igniter"), "igniter")?,
+            douser: read_value::<u16>(stream, definition.get_entry("douser"), "douser")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "igniter" => Ok(self.igniter.clone().into()),
+            "douser" => Ok(self.douser.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "GasDousedPlayerIgnited",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct QuestTurnInStateEvent {
     pub state: u16,
 }
 impl QuestTurnInStateEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(QuestTurnInStateEvent {
-            state: read_value::<u16>(stream, iter.next(), "state")?,
+            state: read_value::<u16>(stream, definition.get_entry("state"), "state")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "state" => Ok(self.state.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "QuestTurnInState",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ItemsAcknowledgedEvent {}
 impl ItemsAcknowledgedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ItemsAcknowledgedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ItemsAcknowledged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct CapperKilledEvent {
     pub blocker: u16,
     pub victim: u16,
@@ -6094,33 +17016,106 @@ pub struct CapperKilledEvent {
 impl CapperKilledEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(CapperKilledEvent {
-            blocker: read_value::<u16>(stream, iter.next(), "blocker")?,
-            victim: read_value::<u16>(stream, iter.next(), "victim")?,
+            blocker: read_value::<u16>(stream, definition.get_entry("blocker"), "blocker")?,
+            victim: read_value::<u16>(stream, definition.get_entry("victim"), "victim")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "blocker" => Ok(self.blocker.clone().into()),
+            "victim" => Ok(self.victim.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "CapperKilled",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct MainMenuStabilizedEvent {}
 impl MainMenuStabilizedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(MainMenuStabilizedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "MainMenuStabilized",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct WorldStatusChangedEvent {}
 impl WorldStatusChangedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(WorldStatusChangedEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "WorldStatusChanged",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVStatusEvent {
     pub clients: u32,
     pub slots: u32,
@@ -6130,31 +17125,86 @@ pub struct HLTVStatusEvent {
 impl HLTVStatusEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVStatusEvent {
-            clients: read_value::<u32>(stream, iter.next(), "clients")?,
-            slots: read_value::<u32>(stream, iter.next(), "slots")?,
-            proxies: read_value::<u16>(stream, iter.next(), "proxies")?,
-            master: read_value::<MaybeUtf8String>(stream, iter.next(), "master")?,
+            clients: read_value::<u32>(stream, definition.get_entry("clients"), "clients")?,
+            slots: read_value::<u32>(stream, definition.get_entry("slots"), "slots")?,
+            proxies: read_value::<u16>(stream, definition.get_entry("proxies"), "proxies")?,
+            master: read_value::<MaybeUtf8String>(
+                stream,
+                definition.get_entry("master"),
+                "master",
+            )?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "clients" => Ok(self.clients.clone().into()),
+            "slots" => Ok(self.slots.clone().into()),
+            "proxies" => Ok(self.proxies.clone().into()),
+            "master" => Ok(self.master.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVStatus",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVCameramanEvent {
     pub index: u16,
 }
 impl HLTVCameramanEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVCameramanEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVCameraman",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVRankCameraEvent {
     pub index: u8,
     pub rank: f32,
@@ -6163,16 +17213,42 @@ pub struct HLTVRankCameraEvent {
 impl HLTVRankCameraEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVRankCameraEvent {
-            index: read_value::<u8>(stream, iter.next(), "index")?,
-            rank: read_value::<f32>(stream, iter.next(), "rank")?,
-            target: read_value::<u16>(stream, iter.next(), "target")?,
-        })
+            index: read_value::<u8>(stream, definition.get_entry("index"), "index")?,
+            rank: read_value::<f32>(stream, definition.get_entry("rank"), "rank")?,
+            target: read_value::<u16>(stream, definition.get_entry("target"), "target")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "rank" => Ok(self.rank.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVRankCamera",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVRankEntityEvent {
     pub index: u16,
     pub rank: f32,
@@ -6181,16 +17257,42 @@ pub struct HLTVRankEntityEvent {
 impl HLTVRankEntityEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVRankEntityEvent {
-            index: read_value::<u16>(stream, iter.next(), "index")?,
-            rank: read_value::<f32>(stream, iter.next(), "rank")?,
-            target: read_value::<u16>(stream, iter.next(), "target")?,
-        })
+            index: read_value::<u16>(stream, definition.get_entry("index"), "index")?,
+            rank: read_value::<f32>(stream, definition.get_entry("rank"), "rank")?,
+            target: read_value::<u16>(stream, definition.get_entry("target"), "target")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "index" => Ok(self.index.clone().into()),
+            "rank" => Ok(self.rank.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVRankEntity",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVFixedEvent {
     pub pos_x: u32,
     pub pos_y: u32,
@@ -6204,21 +17306,52 @@ pub struct HLTVFixedEvent {
 impl HLTVFixedEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVFixedEvent {
-            pos_x: read_value::<u32>(stream, iter.next(), "pos_x")?,
-            pos_y: read_value::<u32>(stream, iter.next(), "pos_y")?,
-            pos_z: read_value::<u32>(stream, iter.next(), "pos_z")?,
-            theta: read_value::<u16>(stream, iter.next(), "theta")?,
-            phi: read_value::<u16>(stream, iter.next(), "phi")?,
-            offset: read_value::<u16>(stream, iter.next(), "offset")?,
-            fov: read_value::<f32>(stream, iter.next(), "fov")?,
-            target: read_value::<u16>(stream, iter.next(), "target")?,
-        })
+            pos_x: read_value::<u32>(stream, definition.get_entry("posx"), "pos_x")?,
+            pos_y: read_value::<u32>(stream, definition.get_entry("posy"), "pos_y")?,
+            pos_z: read_value::<u32>(stream, definition.get_entry("posz"), "pos_z")?,
+            theta: read_value::<u16>(stream, definition.get_entry("theta"), "theta")?,
+            phi: read_value::<u16>(stream, definition.get_entry("phi"), "phi")?,
+            offset: read_value::<u16>(stream, definition.get_entry("offset"), "offset")?,
+            fov: read_value::<f32>(stream, definition.get_entry("fov"), "fov")?,
+            target: read_value::<u16>(stream, definition.get_entry("target"), "target")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "posx" => Ok(self.pos_x.clone().into()),
+            "posy" => Ok(self.pos_y.clone().into()),
+            "posz" => Ok(self.pos_z.clone().into()),
+            "theta" => Ok(self.theta.clone().into()),
+            "phi" => Ok(self.phi.clone().into()),
+            "offset" => Ok(self.offset.clone().into()),
+            "fov" => Ok(self.fov.clone().into()),
+            "target" => Ok(self.target.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVFixed",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVChaseEvent {
     pub target_1: u16,
     pub target_2: u16,
@@ -6231,71 +17364,197 @@ pub struct HLTVChaseEvent {
 impl HLTVChaseEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVChaseEvent {
-            target_1: read_value::<u16>(stream, iter.next(), "target_1")?,
-            target_2: read_value::<u16>(stream, iter.next(), "target_2")?,
-            distance: read_value::<u16>(stream, iter.next(), "distance")?,
-            theta: read_value::<u16>(stream, iter.next(), "theta")?,
-            phi: read_value::<u16>(stream, iter.next(), "phi")?,
-            inertia: read_value::<u8>(stream, iter.next(), "inertia")?,
-            in_eye: read_value::<u8>(stream, iter.next(), "in_eye")?,
-        })
+            target_1: read_value::<u16>(stream, definition.get_entry("target1"), "target_1")?,
+            target_2: read_value::<u16>(stream, definition.get_entry("target2"), "target_2")?,
+            distance: read_value::<u16>(stream, definition.get_entry("distance"), "distance")?,
+            theta: read_value::<u16>(stream, definition.get_entry("theta"), "theta")?,
+            phi: read_value::<u16>(stream, definition.get_entry("phi"), "phi")?,
+            inertia: read_value::<u8>(stream, definition.get_entry("inertia"), "inertia")?,
+            in_eye: read_value::<u8>(stream, definition.get_entry("ineye"), "in_eye")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "target1" => Ok(self.target_1.clone().into()),
+            "target2" => Ok(self.target_2.clone().into()),
+            "distance" => Ok(self.distance.clone().into()),
+            "theta" => Ok(self.theta.clone().into()),
+            "phi" => Ok(self.phi.clone().into()),
+            "inertia" => Ok(self.inertia.clone().into()),
+            "ineye" => Ok(self.in_eye.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVChase",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVMessageEvent {
     pub text: MaybeUtf8String,
 }
 impl HLTVMessageEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVMessageEvent {
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVMessage",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVTitleEvent {
     pub text: MaybeUtf8String,
 }
 impl HLTVTitleEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVTitleEvent {
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVTitle",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct HLTVChatEvent {
     pub text: MaybeUtf8String,
 }
 impl HLTVChatEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(HLTVChatEvent {
-            text: read_value::<MaybeUtf8String>(stream, iter.next(), "text")?,
+            text: read_value::<MaybeUtf8String>(stream, definition.get_entry("text"), "text")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "text" => Ok(self.text.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "HLTVChat",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplayStartRecordEvent {}
 impl ReplayStartRecordEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ReplayStartRecordEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplayStartRecord",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplaySessionInfoEvent {
     pub sn: MaybeUtf8String,
     pub di: u8,
@@ -6305,46 +17564,145 @@ pub struct ReplaySessionInfoEvent {
 impl ReplaySessionInfoEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ReplaySessionInfoEvent {
-            sn: read_value::<MaybeUtf8String>(stream, iter.next(), "sn")?,
-            di: read_value::<u8>(stream, iter.next(), "di")?,
-            cb: read_value::<u32>(stream, iter.next(), "cb")?,
-            st: read_value::<u32>(stream, iter.next(), "st")?,
-        })
+            sn: read_value::<MaybeUtf8String>(stream, definition.get_entry("sn"), "sn")?,
+            di: read_value::<u8>(stream, definition.get_entry("di"), "di")?,
+            cb: read_value::<u32>(stream, definition.get_entry("cb"), "cb")?,
+            st: read_value::<u32>(stream, definition.get_entry("st"), "st")?,
+        })
+    }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "sn" => Ok(self.sn.clone().into()),
+            "di" => Ok(self.di.clone().into()),
+            "cb" => Ok(self.cb.clone().into()),
+            "st" => Ok(self.st.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplaySessionInfo",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
     }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplayEndRecordEvent {}
 impl ReplayEndRecordEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ReplayEndRecordEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplayEndRecord",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplayReplaysAvailableEvent {}
 impl ReplayReplaysAvailableEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
         Ok(ReplayReplaysAvailableEvent {})
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplayReplaysAvailable",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
-#[derive(Debug, BitWrite, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct ReplayServerErrorEvent {
     pub error: MaybeUtf8String,
 }
 impl ReplayServerErrorEvent {
     #[allow(unused_variables)]
     fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
-        let mut iter = definition.entries.iter();
         Ok(ReplayServerErrorEvent {
-            error: read_value::<MaybeUtf8String>(stream, iter.next(), "error")?,
+            error: read_value::<MaybeUtf8String>(stream, definition.get_entry("error"), "error")?,
         })
     }
+    #[allow(unused_variables)]
+    fn get_field(&self, field: &str) -> Result<GameEventValue> {
+        #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
+        match field {
+            "error" => Ok(self.error.clone().into()),
+            _ => Err(ParseError::MissingGameEventValue {
+                ty: "ReplayServerError",
+                field: field.into(),
+            }),
+        }
+    }
+    #[allow(unused_variables)]
+    fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
+        for entry in &definition.entries {
+            let value = self
+                .get_field(&entry.name)
+                .unwrap_or_else(|_| entry.kind.default_value());
+            stream.write(&value)?;
+        }
+        Ok(())
+    }
 }
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
@@ -9591,412 +20949,416 @@ impl GameEvent {
             }
         })
     }
-    pub fn write(&self, stream: &mut BitWriteStream<LittleEndian>) -> bitbuffer::Result<()> {
+    pub fn write(
+        &self,
+        stream: &mut BitWriteStream<LittleEndian>,
+        definition: &GameEventDefinition,
+    ) -> Result<()> {
         match &self {
-            GameEvent::ServerSpawn(event) => event.write(stream),
-            GameEvent::ServerChangeLevelFailed(event) => event.write(stream),
-            GameEvent::ServerShutdown(event) => event.write(stream),
-            GameEvent::ServerCvar(event) => event.write(stream),
-            GameEvent::ServerMessage(event) => event.write(stream),
-            GameEvent::ServerAddBan(event) => event.write(stream),
-            GameEvent::ServerRemoveBan(event) => event.write(stream),
-            GameEvent::PlayerConnect(event) => event.write(stream),
-            GameEvent::PlayerConnectClient(event) => event.write(stream),
-            GameEvent::PlayerInfo(event) => event.write(stream),
-            GameEvent::PlayerDisconnect(event) => event.write(stream),
-            GameEvent::PlayerActivate(event) => event.write(stream),
-            GameEvent::PlayerSay(event) => event.write(stream),
-            GameEvent::ClientDisconnect(event) => event.write(stream),
-            GameEvent::ClientBeginConnect(event) => event.write(stream),
-            GameEvent::ClientConnected(event) => event.write(stream),
-            GameEvent::ClientFullConnect(event) => event.write(stream),
-            GameEvent::HostQuit(event) => event.write(stream),
-            GameEvent::TeamInfo(event) => event.write(stream),
-            GameEvent::TeamScore(event) => event.write(stream),
-            GameEvent::TeamPlayBroadcastAudio(event) => event.write(stream),
-            GameEvent::PlayerTeam(event) => event.write(stream),
-            GameEvent::PlayerClass(event) => event.write(stream),
-            GameEvent::PlayerDeath(event) => event.write(stream),
-            GameEvent::PlayerHurt(event) => event.write(stream),
-            GameEvent::PlayerChat(event) => event.write(stream),
-            GameEvent::PlayerScore(event) => event.write(stream),
-            GameEvent::PlayerSpawn(event) => event.write(stream),
-            GameEvent::PlayerShoot(event) => event.write(stream),
-            GameEvent::PlayerUse(event) => event.write(stream),
-            GameEvent::PlayerChangeName(event) => event.write(stream),
-            GameEvent::PlayerHintMessage(event) => event.write(stream),
-            GameEvent::BasePlayerTeleported(event) => event.write(stream),
-            GameEvent::GameInit(event) => event.write(stream),
-            GameEvent::GameNewMap(event) => event.write(stream),
-            GameEvent::GameStart(event) => event.write(stream),
-            GameEvent::GameEnd(event) => event.write(stream),
-            GameEvent::RoundStart(event) => event.write(stream),
-            GameEvent::RoundEnd(event) => event.write(stream),
-            GameEvent::GameMessage(event) => event.write(stream),
-            GameEvent::BreakBreakable(event) => event.write(stream),
-            GameEvent::BreakProp(event) => event.write(stream),
-            GameEvent::EntityKilled(event) => event.write(stream),
-            GameEvent::BonusUpdated(event) => event.write(stream),
-            GameEvent::AchievementEvent(event) => event.write(stream),
-            GameEvent::AchievementIncrement(event) => event.write(stream),
-            GameEvent::PhysgunPickup(event) => event.write(stream),
-            GameEvent::FlareIgniteNpc(event) => event.write(stream),
-            GameEvent::HelicopterGrenadePuntMiss(event) => event.write(stream),
-            GameEvent::UserDataDownloaded(event) => event.write(stream),
-            GameEvent::RagdollDissolved(event) => event.write(stream),
-            GameEvent::HLTVChangedMode(event) => event.write(stream),
-            GameEvent::HLTVChangedTarget(event) => event.write(stream),
-            GameEvent::VoteEnded(event) => event.write(stream),
-            GameEvent::VoteStarted(event) => event.write(stream),
-            GameEvent::VoteChanged(event) => event.write(stream),
-            GameEvent::VotePassed(event) => event.write(stream),
-            GameEvent::VoteFailed(event) => event.write(stream),
-            GameEvent::VoteCast(event) => event.write(stream),
-            GameEvent::VoteOptions(event) => event.write(stream),
-            GameEvent::ReplaySaved(event) => event.write(stream),
-            GameEvent::EnteredPerformanceMode(event) => event.write(stream),
-            GameEvent::BrowseReplays(event) => event.write(stream),
-            GameEvent::ReplayYoutubeStats(event) => event.write(stream),
-            GameEvent::InventoryUpdated(event) => event.write(stream),
-            GameEvent::CartUpdated(event) => event.write(stream),
-            GameEvent::StorePriceSheetUpdated(event) => event.write(stream),
-            GameEvent::EconInventoryConnected(event) => event.write(stream),
-            GameEvent::ItemSchemaInitialized(event) => event.write(stream),
-            GameEvent::GcNewSession(event) => event.write(stream),
-            GameEvent::GcLostSession(event) => event.write(stream),
-            GameEvent::IntroFinish(event) => event.write(stream),
-            GameEvent::IntroNextCamera(event) => event.write(stream),
-            GameEvent::PlayerChangeClass(event) => event.write(stream),
-            GameEvent::TfMapTimeRemaining(event) => event.write(stream),
-            GameEvent::TfGameOver(event) => event.write(stream),
-            GameEvent::CtfFlagCaptured(event) => event.write(stream),
-            GameEvent::ControlPointInitialized(event) => event.write(stream),
-            GameEvent::ControlPointUpdateImages(event) => event.write(stream),
-            GameEvent::ControlPointUpdateLayout(event) => event.write(stream),
-            GameEvent::ControlPointUpdateCapping(event) => event.write(stream),
-            GameEvent::ControlPointUpdateOwner(event) => event.write(stream),
-            GameEvent::ControlPointStartTouch(event) => event.write(stream),
-            GameEvent::ControlPointEndTouch(event) => event.write(stream),
-            GameEvent::ControlPointPulseElement(event) => event.write(stream),
-            GameEvent::ControlPointFakeCapture(event) => event.write(stream),
-            GameEvent::ControlPointFakeCaptureMultiplier(event) => event.write(stream),
-            GameEvent::TeamPlayRoundSelected(event) => event.write(stream),
-            GameEvent::TeamPlayRoundStart(event) => event.write(stream),
-            GameEvent::TeamPlayRoundActive(event) => event.write(stream),
-            GameEvent::TeamPlayWaitingBegins(event) => event.write(stream),
-            GameEvent::TeamPlayWaitingEnds(event) => event.write(stream),
-            GameEvent::TeamPlayWaitingAboutToEnd(event) => event.write(stream),
-            GameEvent::TeamPlayRestartRound(event) => event.write(stream),
-            GameEvent::TeamPlayReadyRestart(event) => event.write(stream),
-            GameEvent::TeamPlayRoundRestartSeconds(event) => event.write(stream),
-            GameEvent::TeamPlayTeamReady(event) => event.write(stream),
-            GameEvent::TeamPlayRoundWin(event) => event.write(stream),
-            GameEvent::TeamPlayUpdateTimer(event) => event.write(stream),
-            GameEvent::TeamPlayRoundStalemate(event) => event.write(stream),
-            GameEvent::TeamPlayOvertimeBegin(event) => event.write(stream),
-            GameEvent::TeamPlayOvertimeEnd(event) => event.write(stream),
-            GameEvent::TeamPlaySuddenDeathBegin(event) => event.write(stream),
-            GameEvent::TeamPlaySuddenDeathEnd(event) => event.write(stream),
-            GameEvent::TeamPlayGameOver(event) => event.write(stream),
-            GameEvent::TeamPlayMapTimeRemaining(event) => event.write(stream),
-            GameEvent::TeamPlayTimerFlash(event) => event.write(stream),
-            GameEvent::TeamPlayTimerTimeAdded(event) => event.write(stream),
-            GameEvent::TeamPlayPointStartCapture(event) => event.write(stream),
-            GameEvent::TeamPlayPointCaptured(event) => event.write(stream),
-            GameEvent::TeamPlayPointLocked(event) => event.write(stream),
-            GameEvent::TeamPlayPointUnlocked(event) => event.write(stream),
-            GameEvent::TeamPlayCaptureBroken(event) => event.write(stream),
-            GameEvent::TeamPlayCaptureBlocked(event) => event.write(stream),
-            GameEvent::TeamPlayFlagEvent(event) => event.write(stream),
-            GameEvent::TeamPlayWinPanel(event) => event.write(stream),
-            GameEvent::TeamPlayTeamBalancedPlayer(event) => event.write(stream),
-            GameEvent::TeamPlaySetupFinished(event) => event.write(stream),
-            GameEvent::TeamPlayAlert(event) => event.write(stream),
-            GameEvent::TrainingComplete(event) => event.write(stream),
-            GameEvent::ShowFreezePanel(event) => event.write(stream),
-            GameEvent::HideFreezePanel(event) => event.write(stream),
-            GameEvent::FreezeCamStarted(event) => event.write(stream),
-            GameEvent::LocalPlayerChangeTeam(event) => event.write(stream),
-            GameEvent::LocalPlayerScoreChanged(event) => event.write(stream),
-            GameEvent::LocalPlayerChangeClass(event) => event.write(stream),
-            GameEvent::LocalPlayerRespawn(event) => event.write(stream),
-            GameEvent::BuildingInfoChanged(event) => event.write(stream),
-            GameEvent::LocalPlayerChangeDisguise(event) => event.write(stream),
-            GameEvent::PlayerAccountChanged(event) => event.write(stream),
-            GameEvent::SpyPdaReset(event) => event.write(stream),
-            GameEvent::FlagStatusUpdate(event) => event.write(stream),
-            GameEvent::PlayerStatsUpdated(event) => event.write(stream),
-            GameEvent::PlayingCommentary(event) => event.write(stream),
-            GameEvent::PlayerChargeDeployed(event) => event.write(stream),
-            GameEvent::PlayerBuiltObject(event) => event.write(stream),
-            GameEvent::PlayerUpgradedObject(event) => event.write(stream),
-            GameEvent::PlayerCarryObject(event) => event.write(stream),
-            GameEvent::PlayerDropObject(event) => event.write(stream),
-            GameEvent::ObjectRemoved(event) => event.write(stream),
-            GameEvent::ObjectDestroyed(event) => event.write(stream),
-            GameEvent::ObjectDetonated(event) => event.write(stream),
-            GameEvent::AchievementEarned(event) => event.write(stream),
-            GameEvent::SpecTargetUpdated(event) => event.write(stream),
-            GameEvent::TournamentStateUpdate(event) => event.write(stream),
-            GameEvent::TournamentEnableCountdown(event) => event.write(stream),
-            GameEvent::PlayerCalledForMedic(event) => event.write(stream),
-            GameEvent::PlayerAskedForBall(event) => event.write(stream),
-            GameEvent::LocalPlayerBecameObserver(event) => event.write(stream),
-            GameEvent::PlayerIgnitedInv(event) => event.write(stream),
-            GameEvent::PlayerIgnited(event) => event.write(stream),
-            GameEvent::PlayerExtinguished(event) => event.write(stream),
-            GameEvent::PlayerTeleported(event) => event.write(stream),
-            GameEvent::PlayerHealedMedicCall(event) => event.write(stream),
-            GameEvent::LocalPlayerChargeReady(event) => event.write(stream),
-            GameEvent::LocalPlayerWindDown(event) => event.write(stream),
-            GameEvent::PlayerInvulned(event) => event.write(stream),
-            GameEvent::EscortSpeed(event) => event.write(stream),
-            GameEvent::EscortProgress(event) => event.write(stream),
-            GameEvent::EscortRecede(event) => event.write(stream),
-            GameEvent::GameUIActivated(event) => event.write(stream),
-            GameEvent::GameUIHidden(event) => event.write(stream),
-            GameEvent::PlayerEscortScore(event) => event.write(stream),
-            GameEvent::PlayerHealOnHit(event) => event.write(stream),
-            GameEvent::PlayerStealSandvich(event) => event.write(stream),
-            GameEvent::ShowClassLayout(event) => event.write(stream),
-            GameEvent::ShowVsPanel(event) => event.write(stream),
-            GameEvent::PlayerDamaged(event) => event.write(stream),
-            GameEvent::ArenaPlayerNotification(event) => event.write(stream),
-            GameEvent::ArenaMatchMaxStreak(event) => event.write(stream),
-            GameEvent::ArenaRoundStart(event) => event.write(stream),
-            GameEvent::ArenaWinPanel(event) => event.write(stream),
-            GameEvent::PveWinPanel(event) => event.write(stream),
-            GameEvent::AirDash(event) => event.write(stream),
-            GameEvent::Landed(event) => event.write(stream),
-            GameEvent::PlayerDamageDodged(event) => event.write(stream),
-            GameEvent::PlayerStunned(event) => event.write(stream),
-            GameEvent::ScoutGrandSlam(event) => event.write(stream),
-            GameEvent::ScoutSlamdollLanded(event) => event.write(stream),
-            GameEvent::ArrowImpact(event) => event.write(stream),
-            GameEvent::PlayerJarated(event) => event.write(stream),
-            GameEvent::PlayerJaratedFade(event) => event.write(stream),
-            GameEvent::PlayerShieldBlocked(event) => event.write(stream),
-            GameEvent::PlayerPinned(event) => event.write(stream),
-            GameEvent::PlayerHealedByMedic(event) => event.write(stream),
-            GameEvent::PlayerSappedObject(event) => event.write(stream),
-            GameEvent::ItemFound(event) => event.write(stream),
-            GameEvent::ShowAnnotation(event) => event.write(stream),
-            GameEvent::HideAnnotation(event) => event.write(stream),
-            GameEvent::PostInventoryApplication(event) => event.write(stream),
-            GameEvent::ControlPointUnlockUpdated(event) => event.write(stream),
-            GameEvent::DeployBuffBanner(event) => event.write(stream),
-            GameEvent::PlayerBuff(event) => event.write(stream),
-            GameEvent::MedicDeath(event) => event.write(stream),
-            GameEvent::OvertimeNag(event) => event.write(stream),
-            GameEvent::TeamsChanged(event) => event.write(stream),
-            GameEvent::HalloweenPumpkinGrab(event) => event.write(stream),
-            GameEvent::RocketJump(event) => event.write(stream),
-            GameEvent::RocketJumpLanded(event) => event.write(stream),
-            GameEvent::StickyJump(event) => event.write(stream),
-            GameEvent::StickyJumpLanded(event) => event.write(stream),
-            GameEvent::RocketPackLaunch(event) => event.write(stream),
-            GameEvent::RocketPackLanded(event) => event.write(stream),
-            GameEvent::MedicDefended(event) => event.write(stream),
-            GameEvent::LocalPlayerHealed(event) => event.write(stream),
-            GameEvent::PlayerDestroyedPipeBomb(event) => event.write(stream),
-            GameEvent::ObjectDeflected(event) => event.write(stream),
-            GameEvent::PlayerMvp(event) => event.write(stream),
-            GameEvent::RaidSpawnMob(event) => event.write(stream),
-            GameEvent::RaidSpawnSquad(event) => event.write(stream),
-            GameEvent::NavBlocked(event) => event.write(stream),
-            GameEvent::PathTrackPassed(event) => event.write(stream),
-            GameEvent::NumCappersChanged(event) => event.write(stream),
-            GameEvent::PlayerRegenerate(event) => event.write(stream),
-            GameEvent::UpdateStatusItem(event) => event.write(stream),
-            GameEvent::StatsResetRound(event) => event.write(stream),
-            GameEvent::ScoreStatsAccumulatedUpdate(event) => event.write(stream),
-            GameEvent::ScoreStatsAccumulatedReset(event) => event.write(stream),
-            GameEvent::AchievementEarnedLocal(event) => event.write(stream),
-            GameEvent::PlayerHealed(event) => event.write(stream),
-            GameEvent::BuildingHealed(event) => event.write(stream),
-            GameEvent::ItemPickup(event) => event.write(stream),
-            GameEvent::DuelStatus(event) => event.write(stream),
-            GameEvent::FishNotice(event) => event.write(stream),
-            GameEvent::FishNoticeArm(event) => event.write(stream),
-            GameEvent::SlapNotice(event) => event.write(stream),
-            GameEvent::ThrowableHit(event) => event.write(stream),
-            GameEvent::PumpkinLordSummoned(event) => event.write(stream),
-            GameEvent::PumpkinLordKilled(event) => event.write(stream),
-            GameEvent::MerasmusSummoned(event) => event.write(stream),
-            GameEvent::MerasmusKilled(event) => event.write(stream),
-            GameEvent::MerasmusEscapeWarning(event) => event.write(stream),
-            GameEvent::MerasmusEscaped(event) => event.write(stream),
-            GameEvent::EyeballBossSummoned(event) => event.write(stream),
-            GameEvent::EyeballBossStunned(event) => event.write(stream),
-            GameEvent::EyeballBossKilled(event) => event.write(stream),
-            GameEvent::EyeballBossKiller(event) => event.write(stream),
-            GameEvent::EyeballBossEscapeImminent(event) => event.write(stream),
-            GameEvent::EyeballBossEscaped(event) => event.write(stream),
-            GameEvent::NpcHurt(event) => event.write(stream),
-            GameEvent::ControlPointTimerUpdated(event) => event.write(stream),
-            GameEvent::PlayerHighFiveStart(event) => event.write(stream),
-            GameEvent::PlayerHighFiveCancel(event) => event.write(stream),
-            GameEvent::PlayerHighFiveSuccess(event) => event.write(stream),
-            GameEvent::PlayerBonusPoints(event) => event.write(stream),
-            GameEvent::PlayerUpgraded(event) => event.write(stream),
-            GameEvent::PlayerBuyback(event) => event.write(stream),
-            GameEvent::PlayerUsedPowerUpBottle(event) => event.write(stream),
-            GameEvent::ChristmasGiftGrab(event) => event.write(stream),
-            GameEvent::PlayerKilledAchievementZone(event) => event.write(stream),
-            GameEvent::PartyUpdated(event) => event.write(stream),
-            GameEvent::PartyPrefChanged(event) => event.write(stream),
-            GameEvent::PartyCriteriaChanged(event) => event.write(stream),
-            GameEvent::PartyInvitesChanged(event) => event.write(stream),
-            GameEvent::PartyQueueStateChanged(event) => event.write(stream),
-            GameEvent::PartyChat(event) => event.write(stream),
-            GameEvent::PartyMemberJoin(event) => event.write(stream),
-            GameEvent::PartyMemberLeave(event) => event.write(stream),
-            GameEvent::MatchInvitesUpdated(event) => event.write(stream),
-            GameEvent::LobbyUpdated(event) => event.write(stream),
-            GameEvent::MvmMissionUpdate(event) => event.write(stream),
-            GameEvent::RecalculateHolidays(event) => event.write(stream),
-            GameEvent::PlayerCurrencyChanged(event) => event.write(stream),
-            GameEvent::DoomsdayRocketOpen(event) => event.write(stream),
-            GameEvent::RemoveNemesisRelationships(event) => event.write(stream),
-            GameEvent::MvmCreditBonusWave(event) => event.write(stream),
-            GameEvent::MvmCreditBonusAll(event) => event.write(stream),
-            GameEvent::MvmCreditBonusAllAdvanced(event) => event.write(stream),
-            GameEvent::MvmQuickSentryUpgrade(event) => event.write(stream),
-            GameEvent::MvmTankDestroyedByPlayers(event) => event.write(stream),
-            GameEvent::MvmKillRobotDeliveringBomb(event) => event.write(stream),
-            GameEvent::MvmPickupCurrency(event) => event.write(stream),
-            GameEvent::MvmBombCarrierKilled(event) => event.write(stream),
-            GameEvent::MvmSentryBusterDetonate(event) => event.write(stream),
-            GameEvent::MvmScoutMarkedForDeath(event) => event.write(stream),
-            GameEvent::MvmMedicPowerUpShared(event) => event.write(stream),
-            GameEvent::MvmBeginWave(event) => event.write(stream),
-            GameEvent::MvmWaveComplete(event) => event.write(stream),
-            GameEvent::MvmMissionComplete(event) => event.write(stream),
-            GameEvent::MvmBombResetByPlayer(event) => event.write(stream),
-            GameEvent::MvmBombAlarmTriggered(event) => event.write(stream),
-            GameEvent::MvmBombDeployResetByPlayer(event) => event.write(stream),
-            GameEvent::MvmWaveFailed(event) => event.write(stream),
-            GameEvent::MvmResetStats(event) => event.write(stream),
-            GameEvent::DamageResisted(event) => event.write(stream),
-            GameEvent::RevivePlayerNotify(event) => event.write(stream),
-            GameEvent::RevivePlayerStopped(event) => event.write(stream),
-            GameEvent::RevivePlayerComplete(event) => event.write(stream),
-            GameEvent::PlayerTurnedToGhost(event) => event.write(stream),
-            GameEvent::MedigunShieldBlockedDamage(event) => event.write(stream),
-            GameEvent::MvmAdvWaveCompleteNoGates(event) => event.write(stream),
-            GameEvent::MvmSniperHeadshotCurrency(event) => event.write(stream),
-            GameEvent::MvmMannhattanPit(event) => event.write(stream),
-            GameEvent::FlagCarriedInDetectionZone(event) => event.write(stream),
-            GameEvent::MvmAdvWaveKilledStunRadio(event) => event.write(stream),
-            GameEvent::PlayerDirectHitStun(event) => event.write(stream),
-            GameEvent::MvmSentryBusterKilled(event) => event.write(stream),
-            GameEvent::UpgradesFileChanged(event) => event.write(stream),
-            GameEvent::RdTeamPointsChanged(event) => event.write(stream),
-            GameEvent::RdRulesStateChanged(event) => event.write(stream),
-            GameEvent::RdRobotKilled(event) => event.write(stream),
-            GameEvent::RdRobotImpact(event) => event.write(stream),
-            GameEvent::TeamPlayPreRoundTimeLeft(event) => event.write(stream),
-            GameEvent::ParachuteDeploy(event) => event.write(stream),
-            GameEvent::ParachuteHolster(event) => event.write(stream),
-            GameEvent::KillRefillsMeter(event) => event.write(stream),
-            GameEvent::RpsTauntEvent(event) => event.write(stream),
-            GameEvent::CongaKill(event) => event.write(stream),
-            GameEvent::PlayerInitialSpawn(event) => event.write(stream),
-            GameEvent::CompetitiveVictory(event) => event.write(stream),
-            GameEvent::CompetitiveStatsUpdate(event) => event.write(stream),
-            GameEvent::MiniGameWin(event) => event.write(stream),
-            GameEvent::SentryOnGoActive(event) => event.write(stream),
-            GameEvent::DuckXpLevelUp(event) => event.write(stream),
-            GameEvent::QuestLogOpened(event) => event.write(stream),
-            GameEvent::SchemaUpdated(event) => event.write(stream),
-            GameEvent::LocalPlayerPickupWeapon(event) => event.write(stream),
-            GameEvent::RdPlayerScorePoints(event) => event.write(stream),
-            GameEvent::DemomanDetStickies(event) => event.write(stream),
-            GameEvent::QuestObjectiveCompleted(event) => event.write(stream),
-            GameEvent::PlayerScoreChanged(event) => event.write(stream),
-            GameEvent::KilledCappingPlayer(event) => event.write(stream),
-            GameEvent::EnvironmentalDeath(event) => event.write(stream),
-            GameEvent::ProjectileDirectHit(event) => event.write(stream),
-            GameEvent::PassGet(event) => event.write(stream),
-            GameEvent::PassScore(event) => event.write(stream),
-            GameEvent::PassFree(event) => event.write(stream),
-            GameEvent::PassPassCaught(event) => event.write(stream),
-            GameEvent::PassBallStolen(event) => event.write(stream),
-            GameEvent::PassBallBlocked(event) => event.write(stream),
-            GameEvent::DamagePrevented(event) => event.write(stream),
-            GameEvent::HalloweenBossKilled(event) => event.write(stream),
-            GameEvent::EscapedLootIsland(event) => event.write(stream),
-            GameEvent::TaggedPlayerAsIt(event) => event.write(stream),
-            GameEvent::MerasmusStunned(event) => event.write(stream),
-            GameEvent::MerasmusPropFound(event) => event.write(stream),
-            GameEvent::HalloweenSkeletonKilled(event) => event.write(stream),
-            GameEvent::SkeletonKilledQuest(event) => event.write(stream),
-            GameEvent::SkeletonKingKilledQuest(event) => event.write(stream),
-            GameEvent::EscapeHell(event) => event.write(stream),
-            GameEvent::CrossSpectralBridge(event) => event.write(stream),
-            GameEvent::MiniGameWon(event) => event.write(stream),
-            GameEvent::RespawnGhost(event) => event.write(stream),
-            GameEvent::KillInHell(event) => event.write(stream),
-            GameEvent::HalloweenDuckCollected(event) => event.write(stream),
-            GameEvent::SpecialScore(event) => event.write(stream),
-            GameEvent::TeamLeaderKilled(event) => event.write(stream),
-            GameEvent::HalloweenSoulCollected(event) => event.write(stream),
-            GameEvent::RecalculateTruce(event) => event.write(stream),
-            GameEvent::DeadRingerCheatDeath(event) => event.write(stream),
-            GameEvent::CrossbowHeal(event) => event.write(stream),
-            GameEvent::DamageMitigated(event) => event.write(stream),
-            GameEvent::PayloadPushed(event) => event.write(stream),
-            GameEvent::PlayerAbandonedMatch(event) => event.write(stream),
-            GameEvent::ClDrawline(event) => event.write(stream),
-            GameEvent::RestartTimerTime(event) => event.write(stream),
-            GameEvent::WinLimitChanged(event) => event.write(stream),
-            GameEvent::WinPanelShowScores(event) => event.write(stream),
-            GameEvent::TopStreamsRequestFinished(event) => event.write(stream),
-            GameEvent::CompetitiveStateChanged(event) => event.write(stream),
-            GameEvent::GlobalWarDataUpdated(event) => event.write(stream),
-            GameEvent::StopWatchChanged(event) => event.write(stream),
-            GameEvent::DsStop(event) => event.write(stream),
-            GameEvent::DsScreenshot(event) => event.write(stream),
-            GameEvent::ShowMatchSummary(event) => event.write(stream),
-            GameEvent::ExperienceChanged(event) => event.write(stream),
-            GameEvent::BeginXpLerp(event) => event.write(stream),
-            GameEvent::MatchmakerStatsUpdated(event) => event.write(stream),
-            GameEvent::RematchVotePeriodOver(event) => event.write(stream),
-            GameEvent::RematchFailedToCreate(event) => event.write(stream),
-            GameEvent::PlayerRematchChange(event) => event.write(stream),
-            GameEvent::PingUpdated(event) => event.write(stream),
-            GameEvent::MMStatsUpdated(event) => event.write(stream),
-            GameEvent::PlayerNextMapVoteChange(event) => event.write(stream),
-            GameEvent::VoteMapsChanged(event) => event.write(stream),
-            GameEvent::ProtoDefChanged(event) => event.write(stream),
-            GameEvent::PlayerDomination(event) => event.write(stream),
-            GameEvent::PlayerRocketPackPushed(event) => event.write(stream),
-            GameEvent::QuestRequest(event) => event.write(stream),
-            GameEvent::QuestResponse(event) => event.write(stream),
-            GameEvent::QuestProgress(event) => event.write(stream),
-            GameEvent::ProjectileRemoved(event) => event.write(stream),
-            GameEvent::QuestMapDataChanged(event) => event.write(stream),
-            GameEvent::GasDousedPlayerIgnited(event) => event.write(stream),
-            GameEvent::QuestTurnInState(event) => event.write(stream),
-            GameEvent::ItemsAcknowledged(event) => event.write(stream),
-            GameEvent::CapperKilled(event) => event.write(stream),
-            GameEvent::MainMenuStabilized(event) => event.write(stream),
-            GameEvent::WorldStatusChanged(event) => event.write(stream),
-            GameEvent::HLTVStatus(event) => event.write(stream),
-            GameEvent::HLTVCameraman(event) => event.write(stream),
-            GameEvent::HLTVRankCamera(event) => event.write(stream),
-            GameEvent::HLTVRankEntity(event) => event.write(stream),
-            GameEvent::HLTVFixed(event) => event.write(stream),
-            GameEvent::HLTVChase(event) => event.write(stream),
-            GameEvent::HLTVMessage(event) => event.write(stream),
-            GameEvent::HLTVTitle(event) => event.write(stream),
-            GameEvent::HLTVChat(event) => event.write(stream),
-            GameEvent::ReplayStartRecord(event) => event.write(stream),
-            GameEvent::ReplaySessionInfo(event) => event.write(stream),
-            GameEvent::ReplayEndRecord(event) => event.write(stream),
-            GameEvent::ReplayReplaysAvailable(event) => event.write(stream),
-            GameEvent::ReplayServerError(event) => event.write(stream),
-            GameEvent::Unknown(raw) => raw.write(stream),
+            GameEvent::ServerSpawn(event) => event.write(stream, definition),
+            GameEvent::ServerChangeLevelFailed(event) => event.write(stream, definition),
+            GameEvent::ServerShutdown(event) => event.write(stream, definition),
+            GameEvent::ServerCvar(event) => event.write(stream, definition),
+            GameEvent::ServerMessage(event) => event.write(stream, definition),
+            GameEvent::ServerAddBan(event) => event.write(stream, definition),
+            GameEvent::ServerRemoveBan(event) => event.write(stream, definition),
+            GameEvent::PlayerConnect(event) => event.write(stream, definition),
+            GameEvent::PlayerConnectClient(event) => event.write(stream, definition),
+            GameEvent::PlayerInfo(event) => event.write(stream, definition),
+            GameEvent::PlayerDisconnect(event) => event.write(stream, definition),
+            GameEvent::PlayerActivate(event) => event.write(stream, definition),
+            GameEvent::PlayerSay(event) => event.write(stream, definition),
+            GameEvent::ClientDisconnect(event) => event.write(stream, definition),
+            GameEvent::ClientBeginConnect(event) => event.write(stream, definition),
+            GameEvent::ClientConnected(event) => event.write(stream, definition),
+            GameEvent::ClientFullConnect(event) => event.write(stream, definition),
+            GameEvent::HostQuit(event) => event.write(stream, definition),
+            GameEvent::TeamInfo(event) => event.write(stream, definition),
+            GameEvent::TeamScore(event) => event.write(stream, definition),
+            GameEvent::TeamPlayBroadcastAudio(event) => event.write(stream, definition),
+            GameEvent::PlayerTeam(event) => event.write(stream, definition),
+            GameEvent::PlayerClass(event) => event.write(stream, definition),
+            GameEvent::PlayerDeath(event) => event.write(stream, definition),
+            GameEvent::PlayerHurt(event) => event.write(stream, definition),
+            GameEvent::PlayerChat(event) => event.write(stream, definition),
+            GameEvent::PlayerScore(event) => event.write(stream, definition),
+            GameEvent::PlayerSpawn(event) => event.write(stream, definition),
+            GameEvent::PlayerShoot(event) => event.write(stream, definition),
+            GameEvent::PlayerUse(event) => event.write(stream, definition),
+            GameEvent::PlayerChangeName(event) => event.write(stream, definition),
+            GameEvent::PlayerHintMessage(event) => event.write(stream, definition),
+            GameEvent::BasePlayerTeleported(event) => event.write(stream, definition),
+            GameEvent::GameInit(event) => event.write(stream, definition),
+            GameEvent::GameNewMap(event) => event.write(stream, definition),
+            GameEvent::GameStart(event) => event.write(stream, definition),
+            GameEvent::GameEnd(event) => event.write(stream, definition),
+            GameEvent::RoundStart(event) => event.write(stream, definition),
+            GameEvent::RoundEnd(event) => event.write(stream, definition),
+            GameEvent::GameMessage(event) => event.write(stream, definition),
+            GameEvent::BreakBreakable(event) => event.write(stream, definition),
+            GameEvent::BreakProp(event) => event.write(stream, definition),
+            GameEvent::EntityKilled(event) => event.write(stream, definition),
+            GameEvent::BonusUpdated(event) => event.write(stream, definition),
+            GameEvent::AchievementEvent(event) => event.write(stream, definition),
+            GameEvent::AchievementIncrement(event) => event.write(stream, definition),
+            GameEvent::PhysgunPickup(event) => event.write(stream, definition),
+            GameEvent::FlareIgniteNpc(event) => event.write(stream, definition),
+            GameEvent::HelicopterGrenadePuntMiss(event) => event.write(stream, definition),
+            GameEvent::UserDataDownloaded(event) => event.write(stream, definition),
+            GameEvent::RagdollDissolved(event) => event.write(stream, definition),
+            GameEvent::HLTVChangedMode(event) => event.write(stream, definition),
+            GameEvent::HLTVChangedTarget(event) => event.write(stream, definition),
+            GameEvent::VoteEnded(event) => event.write(stream, definition),
+            GameEvent::VoteStarted(event) => event.write(stream, definition),
+            GameEvent::VoteChanged(event) => event.write(stream, definition),
+            GameEvent::VotePassed(event) => event.write(stream, definition),
+            GameEvent::VoteFailed(event) => event.write(stream, definition),
+            GameEvent::VoteCast(event) => event.write(stream, definition),
+            GameEvent::VoteOptions(event) => event.write(stream, definition),
+            GameEvent::ReplaySaved(event) => event.write(stream, definition),
+            GameEvent::EnteredPerformanceMode(event) => event.write(stream, definition),
+            GameEvent::BrowseReplays(event) => event.write(stream, definition),
+            GameEvent::ReplayYoutubeStats(event) => event.write(stream, definition),
+            GameEvent::InventoryUpdated(event) => event.write(stream, definition),
+            GameEvent::CartUpdated(event) => event.write(stream, definition),
+            GameEvent::StorePriceSheetUpdated(event) => event.write(stream, definition),
+            GameEvent::EconInventoryConnected(event) => event.write(stream, definition),
+            GameEvent::ItemSchemaInitialized(event) => event.write(stream, definition),
+            GameEvent::GcNewSession(event) => event.write(stream, definition),
+            GameEvent::GcLostSession(event) => event.write(stream, definition),
+            GameEvent::IntroFinish(event) => event.write(stream, definition),
+            GameEvent::IntroNextCamera(event) => event.write(stream, definition),
+            GameEvent::PlayerChangeClass(event) => event.write(stream, definition),
+            GameEvent::TfMapTimeRemaining(event) => event.write(stream, definition),
+            GameEvent::TfGameOver(event) => event.write(stream, definition),
+            GameEvent::CtfFlagCaptured(event) => event.write(stream, definition),
+            GameEvent::ControlPointInitialized(event) => event.write(stream, definition),
+            GameEvent::ControlPointUpdateImages(event) => event.write(stream, definition),
+            GameEvent::ControlPointUpdateLayout(event) => event.write(stream, definition),
+            GameEvent::ControlPointUpdateCapping(event) => event.write(stream, definition),
+            GameEvent::ControlPointUpdateOwner(event) => event.write(stream, definition),
+            GameEvent::ControlPointStartTouch(event) => event.write(stream, definition),
+            GameEvent::ControlPointEndTouch(event) => event.write(stream, definition),
+            GameEvent::ControlPointPulseElement(event) => event.write(stream, definition),
+            GameEvent::ControlPointFakeCapture(event) => event.write(stream, definition),
+            GameEvent::ControlPointFakeCaptureMultiplier(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundSelected(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundStart(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundActive(event) => event.write(stream, definition),
+            GameEvent::TeamPlayWaitingBegins(event) => event.write(stream, definition),
+            GameEvent::TeamPlayWaitingEnds(event) => event.write(stream, definition),
+            GameEvent::TeamPlayWaitingAboutToEnd(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRestartRound(event) => event.write(stream, definition),
+            GameEvent::TeamPlayReadyRestart(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundRestartSeconds(event) => event.write(stream, definition),
+            GameEvent::TeamPlayTeamReady(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundWin(event) => event.write(stream, definition),
+            GameEvent::TeamPlayUpdateTimer(event) => event.write(stream, definition),
+            GameEvent::TeamPlayRoundStalemate(event) => event.write(stream, definition),
+            GameEvent::TeamPlayOvertimeBegin(event) => event.write(stream, definition),
+            GameEvent::TeamPlayOvertimeEnd(event) => event.write(stream, definition),
+            GameEvent::TeamPlaySuddenDeathBegin(event) => event.write(stream, definition),
+            GameEvent::TeamPlaySuddenDeathEnd(event) => event.write(stream, definition),
+            GameEvent::TeamPlayGameOver(event) => event.write(stream, definition),
+            GameEvent::TeamPlayMapTimeRemaining(event) => event.write(stream, definition),
+            GameEvent::TeamPlayTimerFlash(event) => event.write(stream, definition),
+            GameEvent::TeamPlayTimerTimeAdded(event) => event.write(stream, definition),
+            GameEvent::TeamPlayPointStartCapture(event) => event.write(stream, definition),
+            GameEvent::TeamPlayPointCaptured(event) => event.write(stream, definition),
+            GameEvent::TeamPlayPointLocked(event) => event.write(stream, definition),
+            GameEvent::TeamPlayPointUnlocked(event) => event.write(stream, definition),
+            GameEvent::TeamPlayCaptureBroken(event) => event.write(stream, definition),
+            GameEvent::TeamPlayCaptureBlocked(event) => event.write(stream, definition),
+            GameEvent::TeamPlayFlagEvent(event) => event.write(stream, definition),
+            GameEvent::TeamPlayWinPanel(event) => event.write(stream, definition),
+            GameEvent::TeamPlayTeamBalancedPlayer(event) => event.write(stream, definition),
+            GameEvent::TeamPlaySetupFinished(event) => event.write(stream, definition),
+            GameEvent::TeamPlayAlert(event) => event.write(stream, definition),
+            GameEvent::TrainingComplete(event) => event.write(stream, definition),
+            GameEvent::ShowFreezePanel(event) => event.write(stream, definition),
+            GameEvent::HideFreezePanel(event) => event.write(stream, definition),
+            GameEvent::FreezeCamStarted(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerChangeTeam(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerScoreChanged(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerChangeClass(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerRespawn(event) => event.write(stream, definition),
+            GameEvent::BuildingInfoChanged(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerChangeDisguise(event) => event.write(stream, definition),
+            GameEvent::PlayerAccountChanged(event) => event.write(stream, definition),
+            GameEvent::SpyPdaReset(event) => event.write(stream, definition),
+            GameEvent::FlagStatusUpdate(event) => event.write(stream, definition),
+            GameEvent::PlayerStatsUpdated(event) => event.write(stream, definition),
+            GameEvent::PlayingCommentary(event) => event.write(stream, definition),
+            GameEvent::PlayerChargeDeployed(event) => event.write(stream, definition),
+            GameEvent::PlayerBuiltObject(event) => event.write(stream, definition),
+            GameEvent::PlayerUpgradedObject(event) => event.write(stream, definition),
+            GameEvent::PlayerCarryObject(event) => event.write(stream, definition),
+            GameEvent::PlayerDropObject(event) => event.write(stream, definition),
+            GameEvent::ObjectRemoved(event) => event.write(stream, definition),
+            GameEvent::ObjectDestroyed(event) => event.write(stream, definition),
+            GameEvent::ObjectDetonated(event) => event.write(stream, definition),
+            GameEvent::AchievementEarned(event) => event.write(stream, definition),
+            GameEvent::SpecTargetUpdated(event) => event.write(stream, definition),
+            GameEvent::TournamentStateUpdate(event) => event.write(stream, definition),
+            GameEvent::TournamentEnableCountdown(event) => event.write(stream, definition),
+            GameEvent::PlayerCalledForMedic(event) => event.write(stream, definition),
+            GameEvent::PlayerAskedForBall(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerBecameObserver(event) => event.write(stream, definition),
+            GameEvent::PlayerIgnitedInv(event) => event.write(stream, definition),
+            GameEvent::PlayerIgnited(event) => event.write(stream, definition),
+            GameEvent::PlayerExtinguished(event) => event.write(stream, definition),
+            GameEvent::PlayerTeleported(event) => event.write(stream, definition),
+            GameEvent::PlayerHealedMedicCall(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerChargeReady(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerWindDown(event) => event.write(stream, definition),
+            GameEvent::PlayerInvulned(event) => event.write(stream, definition),
+            GameEvent::EscortSpeed(event) => event.write(stream, definition),
+            GameEvent::EscortProgress(event) => event.write(stream, definition),
+            GameEvent::EscortRecede(event) => event.write(stream, definition),
+            GameEvent::GameUIActivated(event) => event.write(stream, definition),
+            GameEvent::GameUIHidden(event) => event.write(stream, definition),
+            GameEvent::PlayerEscortScore(event) => event.write(stream, definition),
+            GameEvent::PlayerHealOnHit(event) => event.write(stream, definition),
+            GameEvent::PlayerStealSandvich(event) => event.write(stream, definition),
+            GameEvent::ShowClassLayout(event) => event.write(stream, definition),
+            GameEvent::ShowVsPanel(event) => event.write(stream, definition),
+            GameEvent::PlayerDamaged(event) => event.write(stream, definition),
+            GameEvent::ArenaPlayerNotification(event) => event.write(stream, definition),
+            GameEvent::ArenaMatchMaxStreak(event) => event.write(stream, definition),
+            GameEvent::ArenaRoundStart(event) => event.write(stream, definition),
+            GameEvent::ArenaWinPanel(event) => event.write(stream, definition),
+            GameEvent::PveWinPanel(event) => event.write(stream, definition),
+            GameEvent::AirDash(event) => event.write(stream, definition),
+            GameEvent::Landed(event) => event.write(stream, definition),
+            GameEvent::PlayerDamageDodged(event) => event.write(stream, definition),
+            GameEvent::PlayerStunned(event) => event.write(stream, definition),
+            GameEvent::ScoutGrandSlam(event) => event.write(stream, definition),
+            GameEvent::ScoutSlamdollLanded(event) => event.write(stream, definition),
+            GameEvent::ArrowImpact(event) => event.write(stream, definition),
+            GameEvent::PlayerJarated(event) => event.write(stream, definition),
+            GameEvent::PlayerJaratedFade(event) => event.write(stream, definition),
+            GameEvent::PlayerShieldBlocked(event) => event.write(stream, definition),
+            GameEvent::PlayerPinned(event) => event.write(stream, definition),
+            GameEvent::PlayerHealedByMedic(event) => event.write(stream, definition),
+            GameEvent::PlayerSappedObject(event) => event.write(stream, definition),
+            GameEvent::ItemFound(event) => event.write(stream, definition),
+            GameEvent::ShowAnnotation(event) => event.write(stream, definition),
+            GameEvent::HideAnnotation(event) => event.write(stream, definition),
+            GameEvent::PostInventoryApplication(event) => event.write(stream, definition),
+            GameEvent::ControlPointUnlockUpdated(event) => event.write(stream, definition),
+            GameEvent::DeployBuffBanner(event) => event.write(stream, definition),
+            GameEvent::PlayerBuff(event) => event.write(stream, definition),
+            GameEvent::MedicDeath(event) => event.write(stream, definition),
+            GameEvent::OvertimeNag(event) => event.write(stream, definition),
+            GameEvent::TeamsChanged(event) => event.write(stream, definition),
+            GameEvent::HalloweenPumpkinGrab(event) => event.write(stream, definition),
+            GameEvent::RocketJump(event) => event.write(stream, definition),
+            GameEvent::RocketJumpLanded(event) => event.write(stream, definition),
+            GameEvent::StickyJump(event) => event.write(stream, definition),
+            GameEvent::StickyJumpLanded(event) => event.write(stream, definition),
+            GameEvent::RocketPackLaunch(event) => event.write(stream, definition),
+            GameEvent::RocketPackLanded(event) => event.write(stream, definition),
+            GameEvent::MedicDefended(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerHealed(event) => event.write(stream, definition),
+            GameEvent::PlayerDestroyedPipeBomb(event) => event.write(stream, definition),
+            GameEvent::ObjectDeflected(event) => event.write(stream, definition),
+            GameEvent::PlayerMvp(event) => event.write(stream, definition),
+            GameEvent::RaidSpawnMob(event) => event.write(stream, definition),
+            GameEvent::RaidSpawnSquad(event) => event.write(stream, definition),
+            GameEvent::NavBlocked(event) => event.write(stream, definition),
+            GameEvent::PathTrackPassed(event) => event.write(stream, definition),
+            GameEvent::NumCappersChanged(event) => event.write(stream, definition),
+            GameEvent::PlayerRegenerate(event) => event.write(stream, definition),
+            GameEvent::UpdateStatusItem(event) => event.write(stream, definition),
+            GameEvent::StatsResetRound(event) => event.write(stream, definition),
+            GameEvent::ScoreStatsAccumulatedUpdate(event) => event.write(stream, definition),
+            GameEvent::ScoreStatsAccumulatedReset(event) => event.write(stream, definition),
+            GameEvent::AchievementEarnedLocal(event) => event.write(stream, definition),
+            GameEvent::PlayerHealed(event) => event.write(stream, definition),
+            GameEvent::BuildingHealed(event) => event.write(stream, definition),
+            GameEvent::ItemPickup(event) => event.write(stream, definition),
+            GameEvent::DuelStatus(event) => event.write(stream, definition),
+            GameEvent::FishNotice(event) => event.write(stream, definition),
+            GameEvent::FishNoticeArm(event) => event.write(stream, definition),
+            GameEvent::SlapNotice(event) => event.write(stream, definition),
+            GameEvent::ThrowableHit(event) => event.write(stream, definition),
+            GameEvent::PumpkinLordSummoned(event) => event.write(stream, definition),
+            GameEvent::PumpkinLordKilled(event) => event.write(stream, definition),
+            GameEvent::MerasmusSummoned(event) => event.write(stream, definition),
+            GameEvent::MerasmusKilled(event) => event.write(stream, definition),
+            GameEvent::MerasmusEscapeWarning(event) => event.write(stream, definition),
+            GameEvent::MerasmusEscaped(event) => event.write(stream, definition),
+            GameEvent::EyeballBossSummoned(event) => event.write(stream, definition),
+            GameEvent::EyeballBossStunned(event) => event.write(stream, definition),
+            GameEvent::EyeballBossKilled(event) => event.write(stream, definition),
+            GameEvent::EyeballBossKiller(event) => event.write(stream, definition),
+            GameEvent::EyeballBossEscapeImminent(event) => event.write(stream, definition),
+            GameEvent::EyeballBossEscaped(event) => event.write(stream, definition),
+            GameEvent::NpcHurt(event) => event.write(stream, definition),
+            GameEvent::ControlPointTimerUpdated(event) => event.write(stream, definition),
+            GameEvent::PlayerHighFiveStart(event) => event.write(stream, definition),
+            GameEvent::PlayerHighFiveCancel(event) => event.write(stream, definition),
+            GameEvent::PlayerHighFiveSuccess(event) => event.write(stream, definition),
+            GameEvent::PlayerBonusPoints(event) => event.write(stream, definition),
+            GameEvent::PlayerUpgraded(event) => event.write(stream, definition),
+            GameEvent::PlayerBuyback(event) => event.write(stream, definition),
+            GameEvent::PlayerUsedPowerUpBottle(event) => event.write(stream, definition),
+            GameEvent::ChristmasGiftGrab(event) => event.write(stream, definition),
+            GameEvent::PlayerKilledAchievementZone(event) => event.write(stream, definition),
+            GameEvent::PartyUpdated(event) => event.write(stream, definition),
+            GameEvent::PartyPrefChanged(event) => event.write(stream, definition),
+            GameEvent::PartyCriteriaChanged(event) => event.write(stream, definition),
+            GameEvent::PartyInvitesChanged(event) => event.write(stream, definition),
+            GameEvent::PartyQueueStateChanged(event) => event.write(stream, definition),
+            GameEvent::PartyChat(event) => event.write(stream, definition),
+            GameEvent::PartyMemberJoin(event) => event.write(stream, definition),
+            GameEvent::PartyMemberLeave(event) => event.write(stream, definition),
+            GameEvent::MatchInvitesUpdated(event) => event.write(stream, definition),
+            GameEvent::LobbyUpdated(event) => event.write(stream, definition),
+            GameEvent::MvmMissionUpdate(event) => event.write(stream, definition),
+            GameEvent::RecalculateHolidays(event) => event.write(stream, definition),
+            GameEvent::PlayerCurrencyChanged(event) => event.write(stream, definition),
+            GameEvent::DoomsdayRocketOpen(event) => event.write(stream, definition),
+            GameEvent::RemoveNemesisRelationships(event) => event.write(stream, definition),
+            GameEvent::MvmCreditBonusWave(event) => event.write(stream, definition),
+            GameEvent::MvmCreditBonusAll(event) => event.write(stream, definition),
+            GameEvent::MvmCreditBonusAllAdvanced(event) => event.write(stream, definition),
+            GameEvent::MvmQuickSentryUpgrade(event) => event.write(stream, definition),
+            GameEvent::MvmTankDestroyedByPlayers(event) => event.write(stream, definition),
+            GameEvent::MvmKillRobotDeliveringBomb(event) => event.write(stream, definition),
+            GameEvent::MvmPickupCurrency(event) => event.write(stream, definition),
+            GameEvent::MvmBombCarrierKilled(event) => event.write(stream, definition),
+            GameEvent::MvmSentryBusterDetonate(event) => event.write(stream, definition),
+            GameEvent::MvmScoutMarkedForDeath(event) => event.write(stream, definition),
+            GameEvent::MvmMedicPowerUpShared(event) => event.write(stream, definition),
+            GameEvent::MvmBeginWave(event) => event.write(stream, definition),
+            GameEvent::MvmWaveComplete(event) => event.write(stream, definition),
+            GameEvent::MvmMissionComplete(event) => event.write(stream, definition),
+            GameEvent::MvmBombResetByPlayer(event) => event.write(stream, definition),
+            GameEvent::MvmBombAlarmTriggered(event) => event.write(stream, definition),
+            GameEvent::MvmBombDeployResetByPlayer(event) => event.write(stream, definition),
+            GameEvent::MvmWaveFailed(event) => event.write(stream, definition),
+            GameEvent::MvmResetStats(event) => event.write(stream, definition),
+            GameEvent::DamageResisted(event) => event.write(stream, definition),
+            GameEvent::RevivePlayerNotify(event) => event.write(stream, definition),
+            GameEvent::RevivePlayerStopped(event) => event.write(stream, definition),
+            GameEvent::RevivePlayerComplete(event) => event.write(stream, definition),
+            GameEvent::PlayerTurnedToGhost(event) => event.write(stream, definition),
+            GameEvent::MedigunShieldBlockedDamage(event) => event.write(stream, definition),
+            GameEvent::MvmAdvWaveCompleteNoGates(event) => event.write(stream, definition),
+            GameEvent::MvmSniperHeadshotCurrency(event) => event.write(stream, definition),
+            GameEvent::MvmMannhattanPit(event) => event.write(stream, definition),
+            GameEvent::FlagCarriedInDetectionZone(event) => event.write(stream, definition),
+            GameEvent::MvmAdvWaveKilledStunRadio(event) => event.write(stream, definition),
+            GameEvent::PlayerDirectHitStun(event) => event.write(stream, definition),
+            GameEvent::MvmSentryBusterKilled(event) => event.write(stream, definition),
+            GameEvent::UpgradesFileChanged(event) => event.write(stream, definition),
+            GameEvent::RdTeamPointsChanged(event) => event.write(stream, definition),
+            GameEvent::RdRulesStateChanged(event) => event.write(stream, definition),
+            GameEvent::RdRobotKilled(event) => event.write(stream, definition),
+            GameEvent::RdRobotImpact(event) => event.write(stream, definition),
+            GameEvent::TeamPlayPreRoundTimeLeft(event) => event.write(stream, definition),
+            GameEvent::ParachuteDeploy(event) => event.write(stream, definition),
+            GameEvent::ParachuteHolster(event) => event.write(stream, definition),
+            GameEvent::KillRefillsMeter(event) => event.write(stream, definition),
+            GameEvent::RpsTauntEvent(event) => event.write(stream, definition),
+            GameEvent::CongaKill(event) => event.write(stream, definition),
+            GameEvent::PlayerInitialSpawn(event) => event.write(stream, definition),
+            GameEvent::CompetitiveVictory(event) => event.write(stream, definition),
+            GameEvent::CompetitiveStatsUpdate(event) => event.write(stream, definition),
+            GameEvent::MiniGameWin(event) => event.write(stream, definition),
+            GameEvent::SentryOnGoActive(event) => event.write(stream, definition),
+            GameEvent::DuckXpLevelUp(event) => event.write(stream, definition),
+            GameEvent::QuestLogOpened(event) => event.write(stream, definition),
+            GameEvent::SchemaUpdated(event) => event.write(stream, definition),
+            GameEvent::LocalPlayerPickupWeapon(event) => event.write(stream, definition),
+            GameEvent::RdPlayerScorePoints(event) => event.write(stream, definition),
+            GameEvent::DemomanDetStickies(event) => event.write(stream, definition),
+            GameEvent::QuestObjectiveCompleted(event) => event.write(stream, definition),
+            GameEvent::PlayerScoreChanged(event) => event.write(stream, definition),
+            GameEvent::KilledCappingPlayer(event) => event.write(stream, definition),
+            GameEvent::EnvironmentalDeath(event) => event.write(stream, definition),
+            GameEvent::ProjectileDirectHit(event) => event.write(stream, definition),
+            GameEvent::PassGet(event) => event.write(stream, definition),
+            GameEvent::PassScore(event) => event.write(stream, definition),
+            GameEvent::PassFree(event) => event.write(stream, definition),
+            GameEvent::PassPassCaught(event) => event.write(stream, definition),
+            GameEvent::PassBallStolen(event) => event.write(stream, definition),
+            GameEvent::PassBallBlocked(event) => event.write(stream, definition),
+            GameEvent::DamagePrevented(event) => event.write(stream, definition),
+            GameEvent::HalloweenBossKilled(event) => event.write(stream, definition),
+            GameEvent::EscapedLootIsland(event) => event.write(stream, definition),
+            GameEvent::TaggedPlayerAsIt(event) => event.write(stream, definition),
+            GameEvent::MerasmusStunned(event) => event.write(stream, definition),
+            GameEvent::MerasmusPropFound(event) => event.write(stream, definition),
+            GameEvent::HalloweenSkeletonKilled(event) => event.write(stream, definition),
+            GameEvent::SkeletonKilledQuest(event) => event.write(stream, definition),
+            GameEvent::SkeletonKingKilledQuest(event) => event.write(stream, definition),
+            GameEvent::EscapeHell(event) => event.write(stream, definition),
+            GameEvent::CrossSpectralBridge(event) => event.write(stream, definition),
+            GameEvent::MiniGameWon(event) => event.write(stream, definition),
+            GameEvent::RespawnGhost(event) => event.write(stream, definition),
+            GameEvent::KillInHell(event) => event.write(stream, definition),
+            GameEvent::HalloweenDuckCollected(event) => event.write(stream, definition),
+            GameEvent::SpecialScore(event) => event.write(stream, definition),
+            GameEvent::TeamLeaderKilled(event) => event.write(stream, definition),
+            GameEvent::HalloweenSoulCollected(event) => event.write(stream, definition),
+            GameEvent::RecalculateTruce(event) => event.write(stream, definition),
+            GameEvent::DeadRingerCheatDeath(event) => event.write(stream, definition),
+            GameEvent::CrossbowHeal(event) => event.write(stream, definition),
+            GameEvent::DamageMitigated(event) => event.write(stream, definition),
+            GameEvent::PayloadPushed(event) => event.write(stream, definition),
+            GameEvent::PlayerAbandonedMatch(event) => event.write(stream, definition),
+            GameEvent::ClDrawline(event) => event.write(stream, definition),
+            GameEvent::RestartTimerTime(event) => event.write(stream, definition),
+            GameEvent::WinLimitChanged(event) => event.write(stream, definition),
+            GameEvent::WinPanelShowScores(event) => event.write(stream, definition),
+            GameEvent::TopStreamsRequestFinished(event) => event.write(stream, definition),
+            GameEvent::CompetitiveStateChanged(event) => event.write(stream, definition),
+            GameEvent::GlobalWarDataUpdated(event) => event.write(stream, definition),
+            GameEvent::StopWatchChanged(event) => event.write(stream, definition),
+            GameEvent::DsStop(event) => event.write(stream, definition),
+            GameEvent::DsScreenshot(event) => event.write(stream, definition),
+            GameEvent::ShowMatchSummary(event) => event.write(stream, definition),
+            GameEvent::ExperienceChanged(event) => event.write(stream, definition),
+            GameEvent::BeginXpLerp(event) => event.write(stream, definition),
+            GameEvent::MatchmakerStatsUpdated(event) => event.write(stream, definition),
+            GameEvent::RematchVotePeriodOver(event) => event.write(stream, definition),
+            GameEvent::RematchFailedToCreate(event) => event.write(stream, definition),
+            GameEvent::PlayerRematchChange(event) => event.write(stream, definition),
+            GameEvent::PingUpdated(event) => event.write(stream, definition),
+            GameEvent::MMStatsUpdated(event) => event.write(stream, definition),
+            GameEvent::PlayerNextMapVoteChange(event) => event.write(stream, definition),
+            GameEvent::VoteMapsChanged(event) => event.write(stream, definition),
+            GameEvent::ProtoDefChanged(event) => event.write(stream, definition),
+            GameEvent::PlayerDomination(event) => event.write(stream, definition),
+            GameEvent::PlayerRocketPackPushed(event) => event.write(stream, definition),
+            GameEvent::QuestRequest(event) => event.write(stream, definition),
+            GameEvent::QuestResponse(event) => event.write(stream, definition),
+            GameEvent::QuestProgress(event) => event.write(stream, definition),
+            GameEvent::ProjectileRemoved(event) => event.write(stream, definition),
+            GameEvent::QuestMapDataChanged(event) => event.write(stream, definition),
+            GameEvent::GasDousedPlayerIgnited(event) => event.write(stream, definition),
+            GameEvent::QuestTurnInState(event) => event.write(stream, definition),
+            GameEvent::ItemsAcknowledged(event) => event.write(stream, definition),
+            GameEvent::CapperKilled(event) => event.write(stream, definition),
+            GameEvent::MainMenuStabilized(event) => event.write(stream, definition),
+            GameEvent::WorldStatusChanged(event) => event.write(stream, definition),
+            GameEvent::HLTVStatus(event) => event.write(stream, definition),
+            GameEvent::HLTVCameraman(event) => event.write(stream, definition),
+            GameEvent::HLTVRankCamera(event) => event.write(stream, definition),
+            GameEvent::HLTVRankEntity(event) => event.write(stream, definition),
+            GameEvent::HLTVFixed(event) => event.write(stream, definition),
+            GameEvent::HLTVChase(event) => event.write(stream, definition),
+            GameEvent::HLTVMessage(event) => event.write(stream, definition),
+            GameEvent::HLTVTitle(event) => event.write(stream, definition),
+            GameEvent::HLTVChat(event) => event.write(stream, definition),
+            GameEvent::ReplayStartRecord(event) => event.write(stream, definition),
+            GameEvent::ReplaySessionInfo(event) => event.write(stream, definition),
+            GameEvent::ReplayEndRecord(event) => event.write(stream, definition),
+            GameEvent::ReplayReplaysAvailable(event) => event.write(stream, definition),
+            GameEvent::ReplayServerError(event) => event.write(stream, definition),
+            GameEvent::Unknown(raw) => Ok(raw.write(stream)?),
         }
     }
     pub fn event_type(&self) -> GameEventType {
diff --git a/src/demo/gamevent.rs b/src/demo/gamevent.rs
index 2cca1ae..716484f 100644
--- a/src/demo/gamevent.rs
+++ b/src/demo/gamevent.rs
@@ -15,6 +15,12 @@ pub struct GameEventDefinition {
     pub entries: Vec<GameEventEntry>,
 }
 
+impl GameEventDefinition {
+    pub fn get_entry(&self, name: &str) -> Option<&GameEventEntry> {
+        self.entries.iter().find(|entry| entry.name == name)
+    }
+}
+
 impl PartialEq<GameEventDefinition> for GameEventDefinition {
     fn eq(&self, other: &Self) -> bool {
         self.id.eq(&other.id)
@@ -56,6 +62,21 @@ pub enum GameEventValueType {
     Local = 7,
 }
 
+impl GameEventValueType {
+    pub fn default_value(&self) -> GameEventValue {
+        match self {
+            GameEventValueType::None => GameEventValue::Local,
+            GameEventValueType::String => GameEventValue::String(Default::default()),
+            GameEventValueType::Float => GameEventValue::Float(Default::default()),
+            GameEventValueType::Long => GameEventValue::Long(Default::default()),
+            GameEventValueType::Short => GameEventValue::Short(Default::default()),
+            GameEventValueType::Byte => GameEventValue::Byte(Default::default()),
+            GameEventValueType::Boolean => GameEventValue::Boolean(Default::default()),
+            GameEventValueType::Local => GameEventValue::Local,
+        }
+    }
+}
+
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum GameEventValue {
@@ -68,6 +89,42 @@ pub enum GameEventValue {
     Local,
 }
 
+impl From<MaybeUtf8String> for GameEventValue {
+    fn from(value: MaybeUtf8String) -> Self {
+        GameEventValue::String(value)
+    }
+}
+
+impl From<f32> for GameEventValue {
+    fn from(value: f32) -> Self {
+        GameEventValue::Float(value)
+    }
+}
+
+impl From<u32> for GameEventValue {
+    fn from(value: u32) -> Self {
+        GameEventValue::Long(value)
+    }
+}
+
+impl From<u16> for GameEventValue {
+    fn from(value: u16) -> Self {
+        GameEventValue::Short(value)
+    }
+}
+
+impl From<u8> for GameEventValue {
+    fn from(value: u8) -> Self {
+        GameEventValue::Byte(value)
+    }
+}
+
+impl From<bool> for GameEventValue {
+    fn from(value: bool) -> Self {
+        GameEventValue::Boolean(value)
+    }
+}
+
 fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<GameEventValue> {
     Ok(match definition.kind {
         GameEventValueType::String => GameEventValue::String(stream.read()?),
diff --git a/src/demo/lzss.rs b/src/demo/lzss.rs
index d3cf1f0..c8c8997 100644
--- a/src/demo/lzss.rs
+++ b/src/demo/lzss.rs
@@ -1,12 +1,12 @@
-use std::convert::TryInto;
-
 pub fn decompress(input: &[u8], output: &mut Vec<u8>) {
     decompress_(input, output);
 }
 
 /// inner fn that returns an option so we can use ? for short circuiting return
 fn decompress_(input: &[u8], output: &mut Vec<u8>) -> Option<()> {
-    let target_len = u32::from_le_bytes(input[0..4].try_into().unwrap()) as usize;
+    let mut len_bytes = [0; 4];
+    len_bytes.copy_from_slice(input.get(0..4)?);
+    let target_len = u32::from_le_bytes(len_bytes) as usize;
 
     let mut read_pos = 4;
     let mut read_byte = move || {
@@ -35,7 +35,7 @@ fn decompress_(input: &[u8], output: &mut Vec<u8>) -> Option<()> {
                 let start = output.len() - pos - 1;
                 // can't do extend_from_within since it start + count can be larger than output.len
                 for i in 0..count {
-                    output.push(output[start + i]);
+                    output.push(*output.get(start + i)?);
                 }
             } else {
                 output.push(read_byte()?);
diff --git a/src/demo/message/gameevent.rs b/src/demo/message/gameevent.rs
index 063f5ad..1ca8d59 100644
--- a/src/demo/message/gameevent.rs
+++ b/src/demo/message/gameevent.rs
@@ -52,15 +52,18 @@ impl Parse<'_> for GameEventMessage {
 }
 
 impl Encode for GameEventMessage {
-    fn encode(
-        &self,
-        stream: &mut BitWriteStream<LittleEndian>,
-        _state: &ParserState,
-    ) -> Result<()> {
-        Ok(stream.reserve_length(11, |stream| {
+    fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
+        let definition = state
+            .event_definitions
+            .iter()
+            .find(|def| def.event_type == self.event_type)
+            .ok_or(ParseError::MalformedGameEvent(GameEventError::UnknownType(
+                self.event_type_id,
+            )))?;
+        stream.reserve_length(11, |stream| {
             self.event_type_id.write(stream)?;
-            self.event.write(stream)
-        })?)
+            self.event.write(stream, definition)
+        })
     }
 }
 
diff --git a/src/demo/message/mod.rs b/src/demo/message/mod.rs
index a6a010b..6a9f765 100644
--- a/src/demo/message/mod.rs
+++ b/src/demo/message/mod.rs
@@ -26,7 +26,7 @@ pub mod tempentities;
 pub mod usermessage;
 pub mod voice;
 
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema_repr))]
 #[derive(
     BitRead, BitWrite, Debug, Clone, Copy, PartialEq, Eq, Serialize_repr, Deserialize_repr,
 )]
diff --git a/src/demo/message/packetentities.rs b/src/demo/message/packetentities.rs
index 475e3e9..44d5366 100644
--- a/src/demo/message/packetentities.rs
+++ b/src/demo/message/packetentities.rs
@@ -1,4 +1,7 @@
-use bitbuffer::{BitRead, BitReadSized, BitWrite, BitWriteSized, BitWriteStream, LittleEndian};
+use bitbuffer::{
+    BitRead, BitReadSized, BitReadStream, BitWrite, BitWriteSized, BitWriteStream, Endianness,
+    LittleEndian,
+};
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::borrow::Cow;
@@ -72,7 +75,7 @@ impl PartialOrd<u32> for EntityId {
     }
 }
 
-#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema_repr))]
 #[derive(
     BitRead, BitWrite, Clone, Copy, Debug, PartialEq, Eq, Serialize_repr, Deserialize_repr,
 )]
@@ -85,6 +88,57 @@ pub enum UpdateType {
     Delete = 0b11,
 }
 
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema_repr))]
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Serialize_repr, Deserialize_repr, Default)]
+#[repr(u8)]
+pub enum BaselineIndex {
+    #[default]
+    First = 0,
+    Second = 1,
+}
+
+impl BaselineIndex {
+    pub fn other(self) -> Self {
+        match self {
+            BaselineIndex::First => BaselineIndex::Second,
+            BaselineIndex::Second => BaselineIndex::First,
+        }
+    }
+}
+
+impl From<bool> for BaselineIndex {
+    fn from(value: bool) -> Self {
+        match value {
+            false => BaselineIndex::First,
+            true => BaselineIndex::Second,
+        }
+    }
+}
+
+impl<E: Endianness> BitRead<'_, E> for BaselineIndex {
+    fn read(stream: &mut BitReadStream<'_, E>) -> ReadResult<Self> {
+        bool::read(stream).map(BaselineIndex::from)
+    }
+
+    unsafe fn read_unchecked(stream: &mut BitReadStream<'_, E>, end: bool) -> ReadResult<Self> {
+        bool::read_unchecked(stream, end).map(BaselineIndex::from)
+    }
+
+    fn bit_size() -> Option<usize> {
+        Some(1)
+    }
+}
+
+impl<E: Endianness> BitWrite<E> for BaselineIndex {
+    fn write(&self, stream: &mut BitWriteStream<E>) -> ReadResult<()> {
+        let val = match self {
+            BaselineIndex::First => false,
+            BaselineIndex::Second => true,
+        };
+        bool::write(&val, stream)
+    }
+}
+
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct PacketEntity {
@@ -96,7 +150,7 @@ pub struct PacketEntity {
     pub serial_number: u32,
     pub delay: Option<f32>,
     pub delta: Option<ServerTick>,
-    pub baseline_index: usize,
+    pub baseline_index: BaselineIndex,
 }
 
 impl fmt::Display for PacketEntity {
@@ -143,12 +197,15 @@ impl PacketEntity {
     }
 
     pub fn get_baseline_props<'a>(&self, parser_state: &'a ParserState) -> Cow<'a, [SendProp]> {
+        let Some(send_table) = parser_state.send_tables.get(usize::from(self.server_class)) else {
+            return Cow::default();
+        };
         parser_state
             .get_baseline(
                 self.baseline_index,
                 self.entity_index,
                 self.server_class,
-                &parser_state.send_tables[usize::from(self.server_class)],
+                send_table,
                 self.delta.is_some(),
             )
             .unwrap_or_default()
@@ -231,9 +288,9 @@ fn test_bit_var_roundtrip() {
     bit_var_normal(u32::MAX);
 
     for i in 0..31 {
-        bit_var_normal(2u32.pow(i) as u32);
-        bit_var_normal(2u32.pow(i) as u32 - 1);
-        bit_var_normal(2u32.pow(i) as u32 + 1);
+        bit_var_normal(2u32.pow(i));
+        bit_var_normal(2u32.pow(i) - 1);
+        bit_var_normal(2u32.pow(i) + 1);
     }
 }
 
@@ -244,7 +301,7 @@ pub struct PacketEntitiesMessage {
     pub removed_entities: Vec<EntityId>,
     pub max_entries: u16,
     pub delta: Option<ServerTick>,
-    pub base_line: u8,
+    pub base_line: BaselineIndex,
     pub updated_base_line: bool,
 }
 
@@ -275,7 +332,7 @@ fn get_entity_for_update(
         serial_number: 0,
         delay: None,
         delta,
-        baseline_index: 0,
+        baseline_index: BaselineIndex::First,
     })
 }
 
@@ -283,7 +340,7 @@ impl Parse<'_> for PacketEntitiesMessage {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         let max_entries = stream.read_sized(11)?;
         let delta: Option<ServerTick> = stream.read()?;
-        let base_line = stream.read_sized(1)?;
+        let base_line = stream.read()?;
         let updated_entries: u16 = stream.read_sized(11)?;
         let length: u32 = stream.read_sized(20)?;
         let updated_base_line = stream.read()?;
@@ -306,7 +363,7 @@ impl Parse<'_> for PacketEntitiesMessage {
             let update_type = data.read()?;
             if update_type == UpdateType::Enter {
                 let mut entity =
-                    Self::read_enter(&mut data, entity_index, state, base_line as usize, delta)?;
+                    Self::read_enter(&mut data, entity_index, state, base_line, delta)?;
                 let send_table = get_send_table(state, entity.server_class)?;
                 Self::read_update(&mut data, send_table, &mut entity.props, entity_index)?;
 
@@ -332,7 +389,7 @@ impl Parse<'_> for PacketEntitiesMessage {
                     serial_number: 0,
                     delay: None,
                     delta,
-                    baseline_index: 0,
+                    baseline_index: BaselineIndex::First,
                 });
             }
         }
@@ -361,7 +418,7 @@ impl Encode for PacketEntitiesMessage {
         if let Some(delta) = self.delta {
             delta.write(stream)?;
         }
-        self.base_line.write_sized(stream, 1)?;
+        self.base_line.write(stream)?;
         self.entities.len().write_sized(stream, 11)?;
 
         stream.reserve_int(20, |stream| {
@@ -411,7 +468,7 @@ impl PacketEntitiesMessage {
         stream: &mut Stream,
         entity_index: EntityId,
         state: &ParserState,
-        baseline_index: usize,
+        baseline_index: BaselineIndex,
         delta: Option<ServerTick>,
     ) -> Result<PacketEntity> {
         let bits = log_base2(state.server_classes.len()) + 1;
@@ -600,7 +657,7 @@ fn test_packet_entitier_message_roundtrip() {
             removed_entities: vec![],
             max_entries: 0,
             delta: None,
-            base_line: 0,
+            base_line: BaselineIndex::First,
             updated_base_line: false,
         },
         &state,
@@ -616,12 +673,12 @@ fn test_packet_entitier_message_roundtrip() {
                 serial_number: 0,
                 delay: None,
                 delta: None,
-                baseline_index: 0,
+                baseline_index: BaselineIndex::First,
             }],
             removed_entities: vec![],
             max_entries: 4,
             delta: None,
-            base_line: 0,
+            base_line: BaselineIndex::First,
             updated_base_line: false,
         },
         &state,
@@ -638,7 +695,7 @@ fn test_packet_entitier_message_roundtrip() {
                     serial_number: 0,
                     delay: None,
                     delta: None,
-                    baseline_index: 0,
+                    baseline_index: BaselineIndex::First,
                 },
                 PacketEntity {
                     server_class: ClassId::from(1),
@@ -660,13 +717,13 @@ fn test_packet_entitier_message_roundtrip() {
                     serial_number: 0,
                     delay: None,
                     delta: None,
-                    baseline_index: 0,
+                    baseline_index: BaselineIndex::First,
                 },
                 PacketEntity {
                     server_class: ClassId::from(1),
                     entity_index: EntityId::from(5u32),
                     delta: None,
-                    baseline_index: 0,
+                    baseline_index: BaselineIndex::First,
                     props: vec![
                         SendProp {
                             index: 0,
@@ -688,7 +745,7 @@ fn test_packet_entitier_message_roundtrip() {
             removed_entities: vec![],
             max_entries: 4,
             delta: None,
-            base_line: 0,
+            base_line: BaselineIndex::First,
             updated_base_line: false,
         },
         &state,
diff --git a/src/demo/message/stringtable.rs b/src/demo/message/stringtable.rs
index 8515d19..f58d4f9 100644
--- a/src/demo/message/stringtable.rs
+++ b/src/demo/message/stringtable.rs
@@ -1,5 +1,5 @@
 use bitbuffer::{
-    BitReadBuffer, BitReadStream, BitWrite, BitWriteSized, BitWriteStream, LittleEndian,
+    BitError, BitReadBuffer, BitReadStream, BitWrite, BitWriteSized, BitWriteStream, LittleEndian,
 };
 use num_traits::{PrimInt, Unsigned};
 use serde::{Deserialize, Serialize};
@@ -613,7 +613,13 @@ fn write_table_entry(
         if let Some((history_index, history_count)) = history_item {
             history_index.write_sized(stream, 5)?;
             history_count.write_sized(stream, 5)?;
-            let diff_bytes = &text.as_bytes()[history_count..];
+            let diff_bytes =
+                text.as_bytes()
+                    .get(history_count..)
+                    .ok_or(BitError::IndexOutOfBounds {
+                        pos: history_count,
+                        size: text.len(),
+                    })?;
             stream.write_bytes(diff_bytes)?;
             0u8.write(stream)?; // writing the string as bytes doesn't add the null terminator
         } else {
diff --git a/src/demo/message/tempentities.rs b/src/demo/message/tempentities.rs
index 2f1aa5a..83c442d 100644
--- a/src/demo/message/tempentities.rs
+++ b/src/demo/message/tempentities.rs
@@ -97,14 +97,10 @@ impl ParseBitSkip<'_> for TempEntitiesMessage {
 
 impl Encode for TempEntitiesMessage {
     fn encode(&self, stream: &mut BitWriteStream<LittleEndian>, state: &ParserState) -> Result<()> {
-        let count = if self.events.len() == 1 {
-            if self.events[0].reliable {
-                0
-            } else {
-                1
-            }
-        } else {
-            self.events.len() as u8
+        let count = match (self.events.len(), self.events.first()) {
+            (1, Some(event)) if event.reliable => 0,
+            (1, _) => 1,
+            (len, _) => len as u8,
         };
         count.write(stream)?;
 
diff --git a/src/demo/message/usermessage.rs b/src/demo/message/usermessage.rs
index f06db8c..11b7f81 100644
--- a/src/demo/message/usermessage.rs
+++ b/src/demo/message/usermessage.rs
@@ -247,39 +247,43 @@ pub struct SayText2Message {
     pub text: MaybeUtf8String,
 }
 
-impl SayText2Message {
-    pub fn plain_text(&self) -> String {
-        // 1: normal, 2: old colors, 3: team, 4: location, 5 achievement, 6 custom
-        let mut text = self.text.to_string().replace(|c| c <= char::from(6), "");
-        // 7: 6-char hex
-        while let Some(pos) = text.chars().enumerate().find_map(|(index, c)| {
-            if c == char::from(7) {
-                Some(index)
-            } else {
-                None
-            }
-        }) {
-            text = text
-                .chars()
-                .take(pos)
-                .chain(text.chars().skip(pos + 7))
-                .collect();
+fn to_plain_text(text: &str) -> String {
+    // 1: normal, 2: old colors, 3: team, 4: location, 5 achievement, 6 custom
+    let mut text = text.replace(|c| c <= char::from(6), "");
+    // 7: 6-char hex
+    while let Some(pos) = text.chars().enumerate().find_map(|(index, c)| {
+        if c == char::from(7) {
+            Some(index)
+        } else {
+            None
         }
-        // 9: 8-char hex
-        while let Some(pos) = text.chars().enumerate().find_map(|(index, c)| {
-            if c == char::from(9) {
-                Some(index)
-            } else {
-                None
-            }
-        }) {
-            text = text
-                .chars()
-                .take(pos)
-                .chain(text.chars().skip(pos + 9))
-                .collect();
+    }) {
+        text = text
+            .chars()
+            .take(pos)
+            .chain(text.chars().skip(pos + 7))
+            .collect();
+    }
+    // 9: 8-char hex
+    while let Some(pos) = text.chars().enumerate().find_map(|(index, c)| {
+        if c == char::from(9) {
+            Some(index)
+        } else {
+            None
         }
-        text
+    }) {
+        text = text
+            .chars()
+            .take(pos)
+            .chain(text.chars().skip(pos + 9))
+            .collect();
+    }
+    text
+}
+
+impl SayText2Message {
+    pub fn plain_text(&self) -> String {
+        to_plain_text(self.text.as_ref())
     }
 }
 
@@ -364,6 +368,12 @@ pub struct TextMessage {
     pub substitute: [MaybeUtf8String; 4],
 }
 
+impl TextMessage {
+    pub fn plain_text(&self) -> String {
+        to_plain_text(self.text.as_ref())
+    }
+}
+
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[derive(BitRead, BitWrite, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ResetHudMessage {
diff --git a/src/demo/packet/datatable.rs b/src/demo/packet/datatable.rs
index 9742bd4..73636c8 100644
--- a/src/demo/packet/datatable.rs
+++ b/src/demo/packet/datatable.rs
@@ -329,6 +329,7 @@ impl ParseSendTable {
         // sort often changed props before the others
         let mut start = 0;
         for i in 0..flat.len() {
+            #[allow(clippy::indexing_slicing)]
             if flat[i].parse_definition.changes_often() {
                 if i != start {
                     flat.swap(i, start);
diff --git a/src/demo/parser/analyser.rs b/src/demo/parser/analyser.rs
index 850db49..4b35aa7 100644
--- a/src/demo/parser/analyser.rs
+++ b/src/demo/parser/analyser.rs
@@ -3,7 +3,9 @@ use crate::demo::gameevent_gen::{
     GameEvent, PlayerDeathEvent, PlayerSpawnEvent, TeamPlayRoundWinEvent,
 };
 use crate::demo::message::packetentities::EntityId;
-use crate::demo::message::usermessage::{ChatMessageKind, SayText2Message, UserMessage};
+use crate::demo::message::usermessage::{
+    ChatMessageKind, HudTextLocation, SayText2Message, TextMessage, UserMessage,
+};
 use crate::demo::message::{Message, MessageType};
 use crate::demo::packet::stringtable::StringTableEntry;
 use crate::demo::parser::handler::{BorrowMessageHandler, MessageHandler};
@@ -16,7 +18,6 @@ use serde::de::Error;
 use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;
-use std::ops::{Index, IndexMut};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ChatMessage {
@@ -39,6 +40,15 @@ impl ChatMessage {
             tick,
         }
     }
+
+    pub fn from_text(message: &TextMessage, tick: DemoTick) -> Self {
+        ChatMessage {
+            kind: ChatMessageKind::Empty,
+            from: String::new(),
+            text: message.plain_text(),
+            tick,
+        }
+    }
 }
 
 #[derive(
@@ -138,12 +148,12 @@ impl Class {
 }
 
 #[derive(Default, Debug, Eq, PartialEq, Deserialize, Clone)]
-#[serde(from = "HashMap<Class, u8>")]
-pub struct ClassList([u8; 10]);
+#[serde(from = "HashMap<Class, u16>")]
+pub struct ClassList([u16; 10]);
 
 impl ClassList {
     /// Get an iterator for all classes played and the number of spawn on the class
-    pub fn iter(&self) -> impl Iterator<Item = (Class, u8)> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item = (Class, u16)> + '_ {
         self.0
             .iter()
             .copied()
@@ -153,11 +163,23 @@ impl ClassList {
     }
 
     /// Get an iterator for all classes played and the number of spawn on the class, sorted by the number of spawns
-    pub fn sorted(&self) -> impl Iterator<Item = (Class, u8)> {
-        let mut classes = self.iter().collect::<Vec<(Class, u8)>>();
+    pub fn sorted(&self) -> impl Iterator<Item = (Class, u16)> {
+        let mut classes = self.iter().collect::<Vec<(Class, u16)>>();
         classes.sort_by(|a, b| a.1.cmp(&b.1).reverse());
         classes.into_iter()
     }
+
+    pub fn get(&self, class: Class) -> u16 {
+        // class number is always in bounds
+        #[allow(clippy::indexing_slicing)]
+        self.0[class as u8 as usize]
+    }
+
+    pub fn get_mut(&mut self, class: Class) -> &mut u16 {
+        // class number is always in bounds
+        #[allow(clippy::indexing_slicing)]
+        &mut self.0[class as u8 as usize]
+    }
 }
 
 #[test]
@@ -169,22 +191,6 @@ fn test_classlist_sorted() {
     )
 }
 
-impl Index<Class> for ClassList {
-    type Output = u8;
-
-    #[cfg_attr(feature = "no-panic", no_panic::no_panic)]
-    fn index(&self, class: Class) -> &Self::Output {
-        &self.0[class as u8 as usize]
-    }
-}
-
-impl IndexMut<Class> for ClassList {
-    #[cfg_attr(feature = "no-panic", no_panic::no_panic)]
-    fn index_mut(&mut self, class: Class) -> &mut Self::Output {
-        &mut self.0[class as u8 as usize]
-    }
-}
-
 impl Serialize for ClassList {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -202,12 +208,12 @@ impl Serialize for ClassList {
     }
 }
 
-impl From<HashMap<Class, u8>> for ClassList {
-    fn from(map: HashMap<Class, u8>) -> Self {
+impl From<HashMap<Class, u16>> for ClassList {
+    fn from(map: HashMap<Class, u16>) -> Self {
         let mut classes = ClassList::default();
 
         for (class, count) in map.into_iter() {
-            classes[class] = count;
+            *classes.get_mut(class) = count;
         }
 
         classes
@@ -457,16 +463,26 @@ impl Analyser {
     }
 
     fn handle_user_message(&mut self, message: &UserMessage, tick: DemoTick) {
-        if let UserMessage::SayText2(text_message) = message {
-            if text_message.kind == ChatMessageKind::NameChange {
-                if let Some(from) = text_message.from.clone() {
-                    self.change_name(from.into(), text_message.plain_text());
+        match message {
+            UserMessage::SayText2(text_message) => {
+                if text_message.kind == ChatMessageKind::NameChange {
+                    if let Some(from) = text_message.from.clone() {
+                        self.change_name(from.into(), text_message.plain_text());
+                    }
+                } else {
+                    self.state
+                        .chat
+                        .push(ChatMessage::from_message(text_message, tick));
                 }
-            } else {
-                self.state
-                    .chat
-                    .push(ChatMessage::from_message(text_message, tick));
             }
+            UserMessage::Text(text_message) => {
+                if text_message.location == HudTextLocation::PrintTalk {
+                    self.state
+                        .chat
+                        .push(ChatMessage::from_text(text_message, tick));
+                }
+            }
+            _ => {}
         }
     }
 
@@ -484,7 +500,7 @@ impl Analyser {
             GameEvent::PlayerSpawn(event) => {
                 let spawn = Spawn::from_event(event, tick);
                 if let Some(user_state) = self.state.users.get_mut(&spawn.user) {
-                    user_state.classes[spawn.class] += 1;
+                    *user_state.classes.get_mut(spawn.class) += 1;
                     user_state.team = spawn.team;
                 }
             }
diff --git a/src/demo/parser/error.rs b/src/demo/parser/error.rs
index 818d89a..9df995b 100644
--- a/src/demo/parser/error.rs
+++ b/src/demo/parser/error.rs
@@ -63,6 +63,12 @@ pub enum ParseError {
         name: &'static str,
         found_type: GameEventValueType,
     },
+    #[error(
+        display = "Game event of type {} does not contain a {} value",
+        ty,
+        field
+    )]
+    MissingGameEventValue { ty: &'static str, field: String },
     #[error(display = "An entity with an unknown server class({}) was read", _0)]
     UnknownServerClass(ClassId),
     #[error(display = "Unknown send table: {}", _0)]
diff --git a/src/demo/parser/gamestateanalyser.rs b/src/demo/parser/gamestateanalyser.rs
index 285c975..5e736dc 100644
--- a/src/demo/parser/gamestateanalyser.rs
+++ b/src/demo/parser/gamestateanalyser.rs
@@ -282,6 +282,7 @@ impl GameState {
             }
         };
 
+        #[allow(clippy::indexing_slicing)]
         &mut self.players[index]
     }
     pub fn get_or_create_building(
diff --git a/src/demo/parser/state.rs b/src/demo/parser/state.rs
index c56fb8b..bd958bb 100644
--- a/src/demo/parser/state.rs
+++ b/src/demo/parser/state.rs
@@ -5,7 +5,7 @@ use std::collections::HashMap;
 use crate::demo::gamevent::GameEventDefinition;
 
 use crate::demo::message::packetentities::{
-    EntityId, PacketEntitiesMessage, PacketEntity, UpdateType,
+    BaselineIndex, EntityId, PacketEntitiesMessage, PacketEntity, UpdateType,
 };
 use crate::demo::message::stringtable::StringTableMeta;
 use crate::demo::message::{Message, MessageType};
@@ -130,15 +130,29 @@ impl<'a> ParserState {
         // })
     }
 
+    fn get_instance_baseline(&self, index: BaselineIndex) -> &Baseline {
+        match index {
+            BaselineIndex::First => &self.instance_baselines[0],
+            BaselineIndex::Second => &self.instance_baselines[1],
+        }
+    }
+
+    fn get_instance_baseline_mut(&mut self, index: BaselineIndex) -> &mut Baseline {
+        match index {
+            BaselineIndex::First => &mut self.instance_baselines[0],
+            BaselineIndex::Second => &mut self.instance_baselines[1],
+        }
+    }
+
     pub fn get_baseline(
         &self,
-        baseline_index: usize,
+        baseline_index: BaselineIndex,
         entity_index: EntityId,
         class_id: ClassId,
         send_table: &SendTable,
         is_delta: bool,
     ) -> Result<Cow<[SendProp]>> {
-        match self.instance_baselines[baseline_index].get(entity_index) {
+        match self.get_instance_baseline(baseline_index).get(entity_index) {
             Some(baseline) if baseline.server_class == class_id && is_delta => {
                 Ok(Cow::Borrowed(&baseline.props))
             }
@@ -245,10 +259,10 @@ impl<'a> ParserState {
                 }
 
                 if ent_message.updated_base_line {
-                    let old_index = ent_message.base_line as usize;
-                    let new_index = 1 - old_index;
+                    let old_index = ent_message.base_line;
+                    let new_index = old_index.other();
                     let [baseline1, baseline2] = &mut self.instance_baselines;
-                    if old_index == 0 {
+                    if old_index == BaselineIndex::First {
                         baseline2.copy_from(baseline1);
                     } else {
                         baseline1.copy_from(baseline2);
@@ -256,19 +270,22 @@ impl<'a> ParserState {
 
                     for entity in ent_message.entities {
                         if entity.update_type == UpdateType::Enter {
-                            let updated_baseline =
-                                match self.instance_baselines[old_index].get(entity.entity_index) {
-                                    Some(baseline_entity)
-                                        if baseline_entity.server_class == entity.server_class
-                                            && ent_message.delta.is_some() =>
-                                    {
-                                        let mut updated_baseline = baseline_entity.clone();
-                                        updated_baseline.apply_update(&entity.props);
-                                        updated_baseline
-                                    }
-                                    _ => entity.into(),
-                                };
-                            self.instance_baselines[new_index].set(updated_baseline);
+                            let updated_baseline = match self
+                                .get_instance_baseline(old_index)
+                                .get(entity.entity_index)
+                            {
+                                Some(baseline_entity)
+                                    if baseline_entity.server_class == entity.server_class
+                                        && ent_message.delta.is_some() =>
+                                {
+                                    let mut updated_baseline = baseline_entity.clone();
+                                    updated_baseline.apply_update(&entity.props);
+                                    updated_baseline
+                                }
+                                _ => entity.into(),
+                            };
+                            self.get_instance_baseline_mut(new_index)
+                                .set(updated_baseline);
                         }
                     }
                 }
@@ -324,8 +341,9 @@ impl Baseline {
     }
 
     fn set(&mut self, entity: BaselineEntity) {
-        let index = entity.entity_id;
-        self.instances[usize::from(index)] = Some(entity);
+        if let Some(instance) = self.instances.get_mut(usize::from(entity.entity_id)) {
+            *instance = Some(entity);
+        }
     }
 
     pub fn keys(&self) -> impl Iterator<Item = EntityId> + '_ {
@@ -401,7 +419,7 @@ impl From<BaselineEntity> for PacketEntity {
             serial_number: baseline.serial,
             delay: None,
             delta: None,
-            baseline_index: 0,
+            baseline_index: BaselineIndex::First,
         }
     }
 }
diff --git a/src/demo/sendprop.rs b/src/demo/sendprop.rs
index 0a7cdfc..5ae4a97 100644
--- a/src/demo/sendprop.rs
+++ b/src/demo/sendprop.rs
@@ -604,27 +604,17 @@ impl PartialEq for SendPropValue {
             (SendPropValue::VectorXY(value1), SendPropValue::Vector(value2)) => {
                 value1.x == value2.x && value1.y == value2.y && value2.z == 0.0
             }
-            (SendPropValue::Vector(value1), SendPropValue::Array(value2)) if value2.len() == 3 => {
-                SendPropValue::Float(value1.x) == value2[0]
-                    && SendPropValue::Float(value1.y) == value2[1]
-                    && SendPropValue::Float(value1.z) == value2[2]
+            (SendPropValue::Vector(value1), SendPropValue::Array(value2)) => {
+                value1 == value2.as_slice()
             }
-            (SendPropValue::Array(value1), SendPropValue::Vector(value2)) if value1.len() == 3 => {
-                SendPropValue::Float(value2.x) == value1[0]
-                    && SendPropValue::Float(value2.y) == value1[1]
-                    && SendPropValue::Float(value2.z) == value1[2]
+            (SendPropValue::Array(value1), SendPropValue::Vector(value2)) => {
+                value2 == value1.as_slice()
             }
-            (SendPropValue::VectorXY(value1), SendPropValue::Array(value2))
-                if value2.len() == 2 =>
-            {
-                SendPropValue::Float(value1.x) == value2[0]
-                    && SendPropValue::Float(value1.y) == value2[1]
+            (SendPropValue::VectorXY(value1), SendPropValue::Array(value2)) => {
+                value1 == value2.as_slice()
             }
-            (SendPropValue::Array(value1), SendPropValue::VectorXY(value2))
-                if value1.len() == 2 =>
-            {
-                SendPropValue::Float(value2.x) == value1[0]
-                    && SendPropValue::Float(value2.y) == value1[1]
+            (SendPropValue::Array(value1), SendPropValue::VectorXY(value2)) => {
+                value2 == value1.as_slice()
             }
             _ => false,
         }
diff --git a/src/demo/vector.rs b/src/demo/vector.rs
index 859e8d6..22e9d93 100644
--- a/src/demo/vector.rs
+++ b/src/demo/vector.rs
@@ -1,3 +1,4 @@
+use crate::demo::sendprop::SendPropValue;
 use bitbuffer::{BitRead, BitWrite};
 use parse_display::Display;
 use serde::{Deserialize, Serialize};
@@ -24,6 +25,39 @@ impl PartialEq for Vector {
     }
 }
 
+impl PartialEq<[SendPropValue]> for Vector {
+    fn eq(&self, other: &[SendPropValue]) -> bool {
+        match other {
+            &[SendPropValue::Float(x), SendPropValue::Float(y), SendPropValue::Float(z)] => {
+                self.x == x && self.y == y && self.z == z
+            }
+            _ => false,
+        }
+    }
+}
+
+#[test]
+fn test_vec_array_eq() {
+    assert!(!Vector {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+    }
+    .eq([SendPropValue::Float(1.0), SendPropValue::Float(2.0)].as_slice()));
+
+    assert!(Vector {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+    }
+    .eq([
+        SendPropValue::Float(1.0),
+        SendPropValue::Float(2.0),
+        SendPropValue::Float(3.0),
+    ]
+    .as_slice()));
+}
+
 impl Add for Vector {
     type Output = Vector;
 
@@ -62,6 +96,28 @@ impl PartialEq for VectorXY {
     }
 }
 
+impl PartialEq<[SendPropValue]> for VectorXY {
+    fn eq(&self, other: &[SendPropValue]) -> bool {
+        match other {
+            &[SendPropValue::Float(x), SendPropValue::Float(y)] => self.x == x && self.y == y,
+            _ => false,
+        }
+    }
+}
+
+#[test]
+fn test_vec_xy_array_eq() {
+    assert!(VectorXY { x: 1.0, y: 2.0 }
+        .eq([SendPropValue::Float(1.0), SendPropValue::Float(2.0)].as_slice()));
+
+    assert!(!VectorXY { x: 1.0, y: 2.0 }.eq([
+        SendPropValue::Float(1.0),
+        SendPropValue::Float(2.0),
+        SendPropValue::Float(3.0)
+    ]
+    .as_slice()));
+}
+
 impl From<Vector> for VectorXY {
     fn from(vec: Vector) -> Self {
         VectorXY { x: vec.x, y: vec.y }
diff --git a/src/lib.rs b/src/lib.rs
index 1d5f8d1..1f399d0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,8 @@
+#![cfg_attr(not(test), deny(clippy::unwrap_used))]
+#![cfg_attr(not(test), deny(clippy::expect_used))]
+#![cfg_attr(not(test), deny(clippy::indexing_slicing))]
+#![cfg_attr(not(test), deny(clippy::panic))]
+
 pub use bitbuffer::Result as ReadResult;
 
 pub use crate::demo::{
diff --git a/src/nullhasher.rs b/src/nullhasher.rs
index afb38c6..f32620d 100644
--- a/src/nullhasher.rs
+++ b/src/nullhasher.rs
@@ -1,9 +1,10 @@
+use fnv::FnvHasher;
 use serde::{Deserialize, Serialize};
 use std::hash::{BuildHasher, Hasher};
 
 /// A dummy hasher that maps simply returns the hashed u64
 ///
-/// trying to hash anything but a u64 will result in a panic
+/// trying to hash anything but a u64 will result in using fnvhash
 pub struct NullHasher {
     data: u64,
 }
@@ -15,8 +16,14 @@ impl Hasher for NullHasher {
     }
 
     #[inline]
-    fn write(&mut self, _msg: &[u8]) {
-        panic!("can only hash u64,u32,u16");
+    fn write(&mut self, msg: &[u8]) {
+        let mut hasher = FnvHasher::default();
+        hasher.write(msg);
+        self.data = hasher.finish();
+    }
+    #[inline]
+    fn write_u8(&mut self, data: u8) {
+        self.data = data as u64
     }
 
     #[inline]
diff --git a/tests/entity.rs b/tests/entity.rs
index 184a524..b2cc9ea 100644
--- a/tests/entity.rs
+++ b/tests/entity.rs
@@ -88,21 +88,17 @@ impl MessageHandler for EntityDumper {
     type Output = Vec<EntityDump>;
 
     fn does_handle(message_type: MessageType) -> bool {
-        match message_type {
-            MessageType::PacketEntities => true,
-            _ => false,
-        }
+        matches!(message_type, MessageType::PacketEntities)
     }
 
     fn handle_message(&mut self, message: &Message, tick: DemoTick, _parser_state: &ParserState) {
-        match message {
-            Message::PacketEntities(entity_message) => self.entities.extend(
+        if let Message::PacketEntities(entity_message) = message {
+            self.entities.extend(
                 entity_message
                     .entities
                     .iter()
                     .map(|entity| (tick, entity.clone())),
-            ),
-            _ => {}
+            )
         }
     }
 
diff --git a/tests/message_reencode.rs b/tests/message_reencode.rs
index e666f8b..14e18d6 100644
--- a/tests/message_reencode.rs
+++ b/tests/message_reencode.rs
@@ -6,6 +6,25 @@ use tf_demo_parser::demo::packet::Packet;
 use tf_demo_parser::demo::parser::{DemoHandler, Encode, NullHandler};
 use tf_demo_parser::{MessageType, Parse};
 
+fn setup_packet(handler: &mut DemoHandler<NullHandler>, input: &str) {
+    let data = fs::read(input).unwrap();
+    let mut stream = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
+    let packet = Packet::parse(&mut stream, &handler.state_handler).unwrap();
+    handler.handle_packet(packet).unwrap();
+}
+
+fn setup_message(handler: &mut DemoHandler<NullHandler>, input: &str) {
+    let data = fs::read(input).unwrap();
+    let mut stream = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
+    let message = Message::from_type(
+        MessageType::PacketEntities,
+        &mut stream,
+        &handler.state_handler,
+    )
+    .unwrap();
+    handler.handle_message(message, 0.into());
+}
+
 #[test_case("game_event_list.bin", MessageType::GameEventList, &[], &[]; "game_event_list")]
 #[test_case("packet_entities.bin", MessageType::PacketEntities, &["setup_data_tables.bin", "setup_string_tables.bin"], &[]; "packet_entities")]
 #[test_case("packet_entities_pov1.bin", MessageType::PacketEntities, &["setup_data_tables_pov.bin", "setup_string_tables_pov.bin"], &[]; "packet_entities_pov1")]
@@ -56,22 +75,3 @@ fn message_reencode(
         pretty_assertions::assert_eq!(data, out);
     }
 }
-
-fn setup_packet(handler: &mut DemoHandler<NullHandler>, input: &str) {
-    let data = fs::read(input).unwrap();
-    let mut stream = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
-    let packet = Packet::parse(&mut stream, &handler.state_handler).unwrap();
-    handler.handle_packet(packet).unwrap();
-}
-
-fn setup_message(handler: &mut DemoHandler<NullHandler>, input: &str) {
-    let data = fs::read(input).unwrap();
-    let mut stream = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
-    let message = Message::from_type(
-        MessageType::PacketEntities,
-        &mut stream,
-        &handler.state_handler,
-    )
-    .unwrap();
-    handler.handle_message(message, 0.into());
-}
diff --git a/tests/snapshots/tests__comp.dem_minimal.snap b/tests/snapshots/tests__comp.dem_minimal.snap
index 98ac7ca..2465b98 100644
--- a/tests/snapshots/tests__comp.dem_minimal.snap
+++ b/tests/snapshots/tests__comp.dem_minimal.snap
@@ -4,30 +4,90 @@ expression: state
 ---
 {
   "chat": [
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Demo recording completed",
+      "tick": 0
+    },
     {
       "kind": "TF_Chat_All",
       "from": "frying pan",
       "text": "gamers assembly",
       "tick": 16
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Uploading demo auto-20181103-2046-pl_upward.dem",
+      "tick": 204
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Demos must be at least 5 minutes long",
+      "tick": 2638
+    },
     {
       "kind": "TF_Chat_All",
       "from": "Sian",
       "text": "thanks @demos.tf",
       "tick": 3284
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED lost their uber advantage (39 seconds)",
+      "tick": 4376
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 48 seconds before using it",
+      "tick": 12508
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "frying pan",
       "text": ":(",
       "tick": 20640
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU spent 16.6 seconds after spawning before healing",
+      "tick": 23676
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED lost their uber advantage (11 seconds)",
+      "tick": 27124
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED's medic died with 100% uber",
+      "tick": 27540
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Chochy",
       "text": "epic map",
       "tick": 29596
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 80 seconds before using it",
+      "tick": 32424
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED's medic died with 100% uber",
+      "tick": 38084
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Mystt",
@@ -46,6 +106,12 @@ expression: state
       "text": "why are you up there",
       "tick": 46256
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_TeamsSwitched",
+      "tick": 48464
+    },
     {
       "kind": "TF_Chat_All",
       "from": "frying pan",
@@ -58,6 +124,18 @@ expression: state
       "text": "!log",
       "tick": 49060
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU lost their uber advantage (11 seconds)",
+      "tick": 52764
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 72 seconds before using it",
+      "tick": 57374
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Chochy",
@@ -70,6 +148,24 @@ expression: state
       "text": "t",
       "tick": 60618
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU lost their uber advantage (19 seconds)",
+      "tick": 81376
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU's medic died with 100% uber",
+      "tick": 82206
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU spent 9.1 seconds after spawning before healing",
+      "tick": 83404
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Chochy",
@@ -88,6 +184,12 @@ expression: state
       "text": "gg",
       "tick": 85732
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[SOAP] Plugins reloaded.",
+      "tick": 85900
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
diff --git a/tests/snapshots/tests__decal.dem_minimal.snap b/tests/snapshots/tests__decal.dem_minimal.snap
index c084b57..9e5cef4 100644
--- a/tests/snapshots/tests__decal.dem_minimal.snap
+++ b/tests/snapshots/tests__decal.dem_minimal.snap
@@ -34,6 +34,12 @@ expression: state
       "text": "gr",
       "tick": 47043
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_TeamsSwitched",
+      "tick": 47283
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
@@ -394,6 +400,12 @@ expression: state
       "text": "[LogsTF] Uploading logs...",
       "tick": 85836
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Demo recording completed",
+      "tick": 85843
+    },
     {
       "kind": "TF_Chat_Team_Dead",
       "from": "huge obese guy",
@@ -406,6 +418,12 @@ expression: state
       "text": "!log",
       "tick": 86033
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Uploading demo 20190819-2009-pl_upward.dem",
+      "tick": 86033
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
@@ -418,6 +436,12 @@ expression: state
       "text": "[LogsTF] To see the stats, type: !log",
       "tick": 86133
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: json_decode error: Syntax error",
+      "tick": 86218
+    },
     {
       "kind": "TF_Chat_All",
       "from": "^D The Godfather | KING",
diff --git a/tests/snapshots/tests__emptysaytext.dem_minimal.snap b/tests/snapshots/tests__emptysaytext.dem_minimal.snap
index 450e26e..7b5bbd4 100644
--- a/tests/snapshots/tests__emptysaytext.dem_minimal.snap
+++ b/tests/snapshots/tests__emptysaytext.dem_minimal.snap
@@ -4,12 +4,48 @@ expression: state
 ---
 {
   "chat": [
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Demo recording completed",
+      "tick": 1
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: Uploading demo auto-20210602-2316-cp_sunshine.dem",
+      "tick": 200
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[demos.tf]: json_decode error: Syntax error",
+      "tick": 1046
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
       "text": "",
       "tick": 4280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU lost their uber advantage (19 seconds)",
+      "tick": 8693
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 33 seconds before using it",
+      "tick": 9663
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED had uber for 33 seconds before using it",
+      "tick": 10892
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
@@ -40,6 +76,12 @@ expression: state
       "text": "se me parte la cabeza :  tengo a v1lshock clavandome su ojo en la cara",
       "tick": 16714
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED lost their uber advantage (11 seconds)",
+      "tick": 16714
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
@@ -118,18 +160,48 @@ expression: state
       "text": "[PH] Bienvenido a puntero's Hub.",
       "tick": 36280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 33 seconds before using it",
+      "tick": 38818
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED had uber for 31 seconds before using it",
+      "tick": 39002
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
       "text": "[PH] Únete a nuestro Discord para conocer más sobre el servidor: https://discord.gg/bfWRBKGZDQ",
       "tick": 44280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 70 seconds before using it",
+      "tick": 48889
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED had uber for 102 seconds before using it",
+      "tick": 50247
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
       "text": "[PH] ¿Beneficios? Toda información sobre el servidor en nuestro Discord.",
       "tick": 52280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED lost their uber advantage (18 seconds)",
+      "tick": 59620
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
@@ -142,12 +214,24 @@ expression: state
       "text": "",
       "tick": 68280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU had uber for 37 seconds before using it",
+      "tick": 69421
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
       "text": "",
       "tick": 76280
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED lost their uber advantage (12 seconds)",
+      "tick": 76513
+    },
     {
       "kind": "TF_Chat_All",
       "from": "",
diff --git a/tests/snapshots/tests__gully.dem_minimal.snap b/tests/snapshots/tests__gully.dem_minimal.snap
index 9002c05..de618d1 100644
--- a/tests/snapshots/tests__gully.dem_minimal.snap
+++ b/tests/snapshots/tests__gully.dem_minimal.snap
@@ -22,6 +22,12 @@ expression: state
       "text": "[P-REC] Recording...",
       "tick": 8
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Recording started",
+      "tick": 47
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
@@ -34,6 +40,18 @@ expression: state
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 4378
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.10\n",
+      "tick": 4700
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.10\n",
+      "tick": 4700
+    },
     {
       "kind": "TF_Chat_All",
       "from": "distraughtduck4",
@@ -46,12 +64,48 @@ expression: state
       "text": "[LogsTF] To see the stats from the previous rounds, type: .ss",
       "tick": 7479
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 8057
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 12561
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 12777
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.76\n",
+      "tick": 13168
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.76\n",
+      "tick": 13168
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.34\n",
+      "tick": 18133
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.34\n",
+      "tick": 18133
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
@@ -106,6 +160,30 @@ expression: state
       "text": "die meatshot die meatshot DIE DIE",
       "tick": 22725
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.27\n",
+      "tick": 23110
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.27\n",
+      "tick": 23110
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.40\n",
+      "tick": 24368
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.40\n",
+      "tick": 24368
+    },
     {
       "kind": "TF_Chat_All",
       "from": "schy",
@@ -124,18 +202,78 @@ expression: state
       "text": "ns trade",
       "tick": 30781
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.03\n",
+      "tick": 31867
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.03\n",
+      "tick": 31867
+    },
     {
       "kind": "TF_Chat_Team_Dead",
       "from": "Trademark",
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 32301
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.97\n",
+      "tick": 36008
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.97\n",
+      "tick": 36008
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
       "text": ">> FAKE <<  ",
       "tick": 36538
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.26\n",
+      "tick": 40189
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.26\n",
+      "tick": 40189
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.06\n",
+      "tick": 42138
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.06\n",
+      "tick": 42138
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.06\n",
+      "tick": 46341
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.06\n",
+      "tick": 46341
+    },
     {
       "kind": "TF_Chat_All",
       "from": "distraughtduck4",
@@ -148,6 +286,18 @@ expression: state
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 47044
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.80\n",
+      "tick": 47830
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.80\n",
+      "tick": 47830
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "anytime will do my love",
@@ -184,12 +334,24 @@ expression: state
       "text": "ns",
       "tick": 51384
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 51849
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 53540
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 55747
+    },
     {
       "kind": "TF_Chat_All",
       "from": "distraughtduck4",
@@ -214,6 +376,12 @@ expression: state
       "text": "just dont",
       "tick": 61843
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 62024
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "jinta",
@@ -238,6 +406,12 @@ expression: state
       "text": "engi dm",
       "tick": 63679
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 63704
+    },
     {
       "kind": "TF_Chat_All",
       "from": "jinta",
@@ -268,6 +442,30 @@ expression: state
       "text": "u lived i hate u",
       "tick": 67728
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 0.84\n",
+      "tick": 68298
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 0.84\n",
+      "tick": 68298
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.49\n",
+      "tick": 70522
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.49\n",
+      "tick": 70522
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Trademark",
@@ -340,12 +538,30 @@ expression: state
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 76283
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 76353
+    },
     {
       "kind": "TF_Chat_Team_Dead",
       "from": "Trademark",
       "text": "u b e r e d u b e r e d u b e r e d ",
       "tick": 76854
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.30\n",
+      "tick": 77024
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.30\n",
+      "tick": 77024
+    },
     {
       "kind": "TF_Chat_All",
       "from": "anytime will do my love",
@@ -364,6 +580,18 @@ expression: state
       "text": "oh",
       "tick": 80225
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.33\n",
+      "tick": 80357
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.33\n",
+      "tick": 80357
+    },
     {
       "kind": "TF_Chat_All",
       "from": "schy",
@@ -442,6 +670,18 @@ expression: state
       "text": "owned noob",
       "tick": 82584
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.55\n",
+      "tick": 83344
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 2.55\n",
+      "tick": 83344
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
@@ -472,6 +712,66 @@ expression: state
       "text": "schys gay",
       "tick": 85718
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.44\n",
+      "tick": 86149
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.44\n",
+      "tick": 86149
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.46\n",
+      "tick": 86281
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.46\n",
+      "tick": 86281
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.13\n",
+      "tick": 86305
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.13\n",
+      "tick": 86305
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 0.06\n",
+      "tick": 86841
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 0.06\n",
+      "tick": 86841
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.76\n",
+      "tick": 86928
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.76\n",
+      "tick": 86928
+    },
     {
       "kind": "TF_Chat_All",
       "from": "distraughtduck4",
@@ -514,6 +814,12 @@ expression: state
       "text": "meatshot die die DIE",
       "tick": 88336
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[SM] You are flooding the server!",
+      "tick": 88420
+    },
     {
       "kind": "TF_Chat_All",
       "from": "Boog",
@@ -598,6 +904,30 @@ expression: state
       "text": "meatshot die meatshot die MEATSHOT DIE",
       "tick": 89444
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.07\n",
+      "tick": 90243
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 5.07\n",
+      "tick": 90243
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.98\n",
+      "tick": 90449
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 1.98\n",
+      "tick": 90449
+    },
     {
       "kind": "TF_Chat_All",
       "from": "distraughtduck4",
@@ -616,6 +946,18 @@ expression: state
       "text": "meatshot die die DIE",
       "tick": 91124
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.87\n",
+      "tick": 91525
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 6.87\n",
+      "tick": 91525
+    },
     {
       "kind": "TF_Chat_All",
       "from": "Boog",
@@ -646,6 +988,18 @@ expression: state
       "text": "meatshot meatshot meatshot DIE",
       "tick": 95070
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.29\n",
+      "tick": 95499
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 3.29\n",
+      "tick": 95499
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "anytime will do my love",
@@ -688,6 +1042,12 @@ expression: state
       "text": "MEATSHOT DIE DIE",
       "tick": 99674
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 99811
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "jinta",
@@ -718,6 +1078,18 @@ expression: state
       "text": "Ze Venetian Doktor! :  Be Quite im playing you asse",
       "tick": 101398
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Red:  Min Spawn 8.90, Scalar 0.79, Next Spawn In: 4.43\n",
+      "tick": 101811
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Blue: Min Spawn 8.90, Scalar 0.79, Next Spawn In: 4.43\n",
+      "tick": 101811
+    },
     {
       "kind": "TF_Chat_Team",
       "from": "Trademark",
@@ -736,6 +1108,12 @@ expression: state
       "text": "jinta ive seen you win these before",
       "tick": 104434
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#game_spawn_as",
+      "tick": 104764
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "freak u ___",
@@ -802,6 +1180,18 @@ expression: state
       "text": "[LogsTF] Uploading logs...",
       "tick": 105351
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "Recording stopped",
+      "tick": 105351
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "PUG ends with the score 3 to 5.",
+      "tick": 105351
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "tridud",
diff --git a/tests/snapshots/tests__malformed_cvar.dem_minimal.snap b/tests/snapshots/tests__malformed_cvar.dem_minimal.snap
index 49c1ada..28bfa1f 100644
--- a/tests/snapshots/tests__malformed_cvar.dem_minimal.snap
+++ b/tests/snapshots/tests__malformed_cvar.dem_minimal.snap
@@ -16,6 +16,78 @@ expression: state
       "text": "thanks",
       "tick": 5000
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU's medic died with 100% uber",
+      "tick": 5328
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU spent 7.4 seconds after spawning before healing",
+      "tick": 6926
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU's medic died with 99% uber",
+      "tick": 10588
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU spent 9.0 seconds after spawning before healing",
+      "tick": 28546
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED spent 11.4 seconds after spawning before healing",
+      "tick": 28786
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED's medic died with 100% uber",
+      "tick": 33083
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED spent 17.0 seconds after spawning before healing",
+      "tick": 35446
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED's medic died with 100% uber",
+      "tick": 40339
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED spent 11.3 seconds after spawning before healing",
+      "tick": 42406
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU spent 19.4 seconds after spawning before healing",
+      "tick": 44226
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] BLU's medic died with 100% uber",
+      "tick": 47735
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED had uber for 35 seconds before using it",
+      "tick": 61463
+    },
     {
       "kind": "TF_Chat_All",
       "from": "master race",
@@ -28,6 +100,12 @@ expression: state
       "text": "gr",
       "tick": 62805
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[STV Stats] RED spent 8.5 seconds after spawning before healing",
+      "tick": 66293
+    },
     {
       "kind": "TF_Chat_AllDead",
       "from": "Donald Stump",
@@ -105,6 +183,12 @@ expression: state
       "from": "",
       "text": "[LogsTF] Uploading logs...",
       "tick": 80333
+    },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "[SOAP] Plugins reloaded.",
+      "tick": 80333
     }
   ],
   "users": {
diff --git a/tests/snapshots/tests__protocol23.dem_minimal.snap b/tests/snapshots/tests__protocol23.dem_minimal.snap
index e48d518..74b5182 100644
--- a/tests/snapshots/tests__protocol23.dem_minimal.snap
+++ b/tests/snapshots/tests__protocol23.dem_minimal.snap
@@ -10,6 +10,12 @@ expression: state
       "text": "[P-REC] Recording...",
       "tick": 110
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_TeamsSwitched",
+      "tick": 110
+    },
     {
       "kind": "TF_Chat_All",
       "from": "[GC]Kimo [DK]",
@@ -352,6 +358,12 @@ expression: state
       "text": "gj",
       "tick": 39077
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_TeamsSwitched",
+      "tick": 39153
+    },
     {
       "kind": "TF_Chat_All",
       "from": "[GC]Coféeee",
diff --git a/tests/snapshots/tests__saytext2.dem_minimal.snap b/tests/snapshots/tests__saytext2.dem_minimal.snap
index 320809d..75d6c0f 100644
--- a/tests/snapshots/tests__saytext2.dem_minimal.snap
+++ b/tests/snapshots/tests__saytext2.dem_minimal.snap
@@ -136,6 +136,12 @@ expression: state
       "text": "gr",
       "tick": 36278
     },
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_TeamsSwitched",
+      "tick": 36300
+    },
     {
       "kind": "TF_Chat_All",
       "from": "Pride | Mafia Boss",
diff --git a/tests/snapshots/tests__small.dem_minimal.snap b/tests/snapshots/tests__small.dem_minimal.snap
index 0c86d11..36a5635 100644
--- a/tests/snapshots/tests__small.dem_minimal.snap
+++ b/tests/snapshots/tests__small.dem_minimal.snap
@@ -3,7 +3,14 @@ source: tests/tests.rs
 expression: state
 ---
 {
-  "chat": [],
+  "chat": [
+    {
+      "kind": "Empty",
+      "from": "",
+      "text": "#TF_timeleft",
+      "tick": 4
+    }
+  ],
   "users": {
     "2": {
       "classes": {},