diff --git a/dart/lib/flat_buffers.dart b/dart/lib/flat_buffers.dart
index 7590bdba690..bdf337cc1ae 100644
--- a/dart/lib/flat_buffers.dart
+++ b/dart/lib/flat_buffers.dart
@@ -1022,6 +1022,42 @@ class ListReader<E> extends Reader<List<E>> {
   }
 }
 
+/// The reader of lists of objects. Lazy by default - see [lazy].
+class UnionListReader<E> extends Reader<List<E?>> {
+  final Reader<E>? Function(int index) _getElementReader;
+
+  /// Enables lazy reading of the list
+  ///
+  /// If true, the returned unmodifiable list lazily reads objects on access.
+  /// Therefore, the underlying buffer must not change while accessing the list.
+  ///
+  /// If false, reads the whole list immediately on access.
+  final bool lazy;
+
+  const UnionListReader(this._getElementReader, {this.lazy = true});
+
+  @override
+  @pragma('vm:prefer-inline')
+  int get size => _sizeofUint32;
+
+  @override
+  List<E?> read(BufferContext bc, int offset) {
+    final listOffset = bc.derefObject(offset);
+    return lazy
+        ? _FbUnionList<E>(_getElementReader, bc, listOffset)
+        : List<E?>.generate(
+            bc.buffer.getUint32(listOffset, Endian.little),
+            (int index) {
+              final reader = _getElementReader(index);
+              if (reader == null) return null;
+              int offset = listOffset + size + _sizeofUint32 * index;
+              return reader.read(bc, offset);
+            },
+            growable: true,
+          );
+  }
+}
+
 /// Object that can read a value at a [BufferContext].
 abstract class Reader<T> {
   const Reader();
@@ -1121,6 +1157,25 @@ abstract class TableReader<T> extends Reader<T> {
   }
 }
 
+/// A reader that wraps another reader if the type is a union.
+///
+/// This is useful for reading unions that can be stucts and need an extra
+/// derefObject call.
+class UnionReader<T> extends Reader<T?> {
+  final Reader<T>? reader;
+
+  const UnionReader(this.reader);
+
+  @override
+  int get size => 4;
+
+  @override
+  T? read(BufferContext bc, int offset) {
+    if (reader is StructReader) offset = bc.derefObject(offset);
+    return reader?.read(bc, offset);
+  }
+}
+
 /// Reader of lists of unsigned 32-bit integer values.
 ///
 /// The returned unmodifiable lists lazily read values on access.
@@ -1311,6 +1366,29 @@ class _FbGenericList<E> extends _FbList<E> {
   }
 }
 
+/// Lazy list of union objects
+class _FbUnionList<E> extends _FbList<E?> {
+  final Reader<E>? Function(int index) getElementReader;
+
+  List<E?>? _items;
+
+  _FbUnionList(this.getElementReader, BufferContext bp, int offset)
+      : super(bp, offset);
+
+  @override
+  @pragma('vm:prefer-inline')
+  E? operator [](int i) {
+    _items ??= List<E?>.filled(length, null);
+    var item = _items![i];
+    final reader = getElementReader(i);
+    if (item == null && reader != null) {
+      item = reader.read(bc, offset + 4 + 4 * i);
+      _items![i] = item;
+    }
+    return item!;
+  }
+}
+
 /// The base class for immutable lists read from flat buffers.
 abstract class _FbList<E> extends Object with ListMixin<E> implements List<E> {
   final BufferContext bc;
diff --git a/dart/test/flat_buffers_test.dart b/dart/test/flat_buffers_test.dart
index c4a146f8db5..71e4dc69d43 100644
--- a/dart/test/flat_buffers_test.dart
+++ b/dart/test/flat_buffers_test.dart
@@ -10,6 +10,7 @@ import './bool_structs_generated.dart' as example4;
 import './monster_test_my_game.example2_generated.dart' as example2;
 import './monster_test_my_game.example_generated.dart' as example;
 import 'enums_generated.dart' as example3;
+import 'union_vector_generated.dart' as example5;
 
 main() {
   defineReflectiveSuite(() {
@@ -18,6 +19,7 @@ main() {
     defineReflectiveTests(CheckOtherLangaugesData);
     defineReflectiveTests(GeneratorTest);
     defineReflectiveTests(ListOfEnumsTest);
+    defineReflectiveTests(UnionVectorTest);
   });
 }
 
@@ -934,6 +936,81 @@ class ObjectAPITest {
   }
 }
 
+@reflectiveTest
+class UnionVectorTest {
+  void test_unionVector() {
+    final movie = example5.MovieT(
+      mainCharacterType: example5.CharacterTypeId.Rapunzel,
+      mainCharacter: example5.RapunzelT(hairLength: 42),
+      charactersType: [
+        example5.CharacterTypeId.MuLan,
+        example5.CharacterTypeId.Rapunzel,
+        example5.CharacterTypeId.Belle,
+        example5.CharacterTypeId.BookFan,
+        example5.CharacterTypeId.Other,
+        example5.CharacterTypeId.Unused,
+      ],
+      characters: [
+        example5.AttackerT(swordAttackDamage: 10),
+        example5.RapunzelT(hairLength: 203),
+        example5.BookReaderT(booksRead: 21),
+        example5.BookReaderT(booksRead: 500),
+        "Hello",
+        "World",
+      ],
+    );
+
+    final fbb = Builder();
+    fbb.finish(movie.pack(fbb));
+
+    final movie2 = example5.Movie(fbb.buffer);
+    expect(
+      movie2.toString().replaceAllMapped(
+          RegExp('([a-zA-Z0-9]+){'), (match) => match.group(1)! + 'T{'),
+      movie.toString(),
+    );
+
+    final movie3 = movie2.unpack();
+    expect(movie3.toString(), movie.toString());
+
+    final movie4 = example5.MovieT(
+      mainCharacter: "String",
+      mainCharacterType: example5.CharacterTypeId.Other,
+    );
+
+    fbb.reset();
+    fbb.finish(movie4.pack(fbb));
+
+    final movie5 = example5.Movie(fbb.buffer);
+    expect(
+      movie5.toString().replaceAllMapped(
+          RegExp('([a-zA-Z0-9]+){'), (match) => match.group(1)! + 'T{'),
+      movie4.toString(),
+    );
+
+    final movie6 = movie5.unpack();
+    expect(movie6.toString(), movie4.toString());
+
+    final movie7 = example5.MovieT(
+      mainCharacter: example5.AttackerT(swordAttackDamage: 43),
+      mainCharacterType: example5.CharacterTypeId.MuLan,
+    );
+
+    fbb.reset();
+    fbb.finish(movie7.pack(fbb));
+
+    final movie8 = example5.Movie(fbb.buffer);
+    expect(
+      movie8.toString().replaceAllMapped(
+          RegExp('([a-zA-Z0-9]+){'), (match) => match.group(1)! + 'T{'),
+      movie7.toString(),
+    );
+
+    final movie9 = movie8.unpack();
+    expect(movie9.toString(), movie7.toString());
+  }
+}
+
 class StringListWrapperImpl {
   final BufferContext bp;
   final int offset;
diff --git a/dart/test/keyword_test_keyword_test_generated.dart b/dart/test/keyword_test_keyword_test_generated.dart
index 4f5d464ae09..278dd180e9f 100644
--- a/dart/test/keyword_test_keyword_test_generated.dart
+++ b/dart/test/keyword_test_keyword_test_generated.dart
@@ -112,6 +112,18 @@ class _KeywordsInUnionTypeIdReader extends fb.Reader<KeywordsInUnionTypeId> {
       KeywordsInUnionTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
+class _KeywordsInUnionReader extends fb.UnionReader {
+  _KeywordsInUnionReader(KeywordsInUnionTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(KeywordsInUnionTypeId? type) {
+    switch (type?.value) {
+      case 1: return KeywordsInTable.reader;
+      case 2: return KeywordsInTable.reader;
+      default: return null;
+    }
+  }
+}
+
 class KeywordsInTable {
   KeywordsInTable._(this._bc, this._bcOffset);
   factory KeywordsInTable(List<int> bytes) {
@@ -262,13 +274,7 @@ class Table2 {
   final int _bcOffset;
 
   KeywordsInUnionTypeId? get typeType => KeywordsInUnionTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 4));
-  dynamic get type {
-    switch (typeType?.value) {
-      case 1: return KeywordsInTable.reader.vTableGetNullable(_bc, _bcOffset, 6);
-      case 2: return KeywordsInTable.reader.vTableGetNullable(_bc, _bcOffset, 6);
-      default: return null;
-    }
-  }
+  dynamic get type => _KeywordsInUnionReader(typeType).vTableGetNullable(_bc, _bcOffset, 6);
 
   @override
   String toString() {
@@ -277,7 +283,7 @@ class Table2 {
 
   Table2T unpack() => Table2T(
       typeType: typeType,
-      type: type?.unpack());
+      type: type is String ? type : type?.unpack());
 
   static int pack(fb.Builder fbBuilder, Table2T? object) {
     if (object == null) return 0;
@@ -295,7 +301,7 @@ class Table2T implements fb.Packable {
 
   @override
   int pack(fb.Builder fbBuilder) {
-    final int? typeOffset = type?.pack(fbBuilder);
+    final int? typeOffset = type is String ? fbBuilder.writeString(type) : type?.pack(fbBuilder);
     fbBuilder.startTable(2);
     fbBuilder.addUint8(0, typeType?.value);
     fbBuilder.addOffset(1, typeOffset);
@@ -353,7 +359,7 @@ class Table2ObjectBuilder extends fb.ObjectBuilder {
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
-    final int? typeOffset = _type?.getOrCreateOffset(fbBuilder);
+    final int? typeOffset = _type is String ? fbBuilder.writeString(_type) : _type?.getOrCreateOffset(fbBuilder);
     fbBuilder.startTable(2);
     fbBuilder.addUint8(0, _typeType?.value);
     fbBuilder.addOffset(1, typeOffset);
diff --git a/dart/test/monster_test_my_game.example_generated.dart b/dart/test/monster_test_my_game.example_generated.dart
index 9a791353e3d..d9bb8ce3c2a 100644
--- a/dart/test/monster_test_my_game.example_generated.dart
+++ b/dart/test/monster_test_my_game.example_generated.dart
@@ -180,6 +180,23 @@ class _AnyTypeIdReader extends fb.Reader<AnyTypeId> {
       AnyTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
+class _AnyReader extends fb.UnionReader {
+  _AnyReader(AnyTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(AnyTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return TestSimpleTableWithEnum.reader;
+      case 3:
+        return my_game_example2.Monster.reader;
+      default:
+        return null;
+    }
+  }
+}
+
 enum AnyUniqueAliasesTypeId {
   NONE(0),
   M(1),
@@ -224,6 +241,23 @@ class _AnyUniqueAliasesTypeIdReader extends fb.Reader<AnyUniqueAliasesTypeId> {
       AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
+class _AnyUniqueAliasesReader extends fb.UnionReader {
+  _AnyUniqueAliasesReader(AnyUniqueAliasesTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(AnyUniqueAliasesTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return TestSimpleTableWithEnum.reader;
+      case 3:
+        return my_game_example2.Monster.reader;
+      default:
+        return null;
+    }
+  }
+}
+
 enum AnyAmbiguousAliasesTypeId {
   NONE(0),
   M1(1),
@@ -271,6 +305,24 @@ class _AnyAmbiguousAliasesTypeIdReader
       );
 }
 
+class _AnyAmbiguousAliasesReader extends fb.UnionReader {
+  _AnyAmbiguousAliasesReader(AnyAmbiguousAliasesTypeId? type)
+    : super(_get(type));
+
+  static fb.Reader? _get(AnyAmbiguousAliasesTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return Monster.reader;
+      case 3:
+        return Monster.reader;
+      default:
+        return null;
+    }
+  }
+}
+
 class Test {
   Test._(this._bc, this._bcOffset);
 
@@ -342,7 +394,9 @@ class TestObjectBuilder extends fb.ObjectBuilder {
   final int _a;
   final int _b;
 
-  TestObjectBuilder({required int a, required int b}) : _a = a, _b = b;
+  TestObjectBuilder({required int a, required int b})
+      : _a = a,
+        _b = b;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -481,13 +535,13 @@ class Vec3 {
   }
 
   Vec3T unpack() => Vec3T(
-    x: x,
-    y: y,
-    z: z,
-    test1: test1,
-    test2: test2,
-    test3: test3.unpack(),
-  );
+        x: x,
+        y: y,
+        z: z,
+        test1: test1,
+        test2: test2,
+        test3: test3.unpack(),
+      );
 
   static int pack(fb.Builder fbBuilder, Vec3T? object) {
     if (object == null) return 0;
@@ -583,12 +637,12 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
     required double test1,
     required Color test2,
     required TestObjectBuilder test3,
-  }) : _x = x,
-       _y = y,
-       _z = z,
-       _test1 = test1,
-       _test2 = test2,
-       _test3 = test3;
+  })  : _x = x,
+        _y = y,
+        _z = z,
+        _test1 = test1,
+        _test2 = test2,
+        _test3 = test3;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -685,8 +739,8 @@ class AbilityObjectBuilder extends fb.ObjectBuilder {
   final int _distance;
 
   AbilityObjectBuilder({required int id, required int distance})
-    : _id = id,
-      _distance = distance;
+      : _id = id,
+        _distance = distance;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -785,9 +839,9 @@ class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
     required AbilityObjectBuilder a,
     required TestObjectBuilder b,
     required AbilityObjectBuilder c,
-  }) : _a = a,
-       _b = b,
-       _c = c;
+  })  : _a = a,
+        _b = b,
+        _c = c;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -990,9 +1044,9 @@ class StatObjectBuilder extends fb.ObjectBuilder {
   final int? _count;
 
   StatObjectBuilder({String? id, int? val, int? count})
-    : _id = id,
-      _val = val,
-      _count = count;
+      : _id = id,
+        _val = val,
+        _count = count;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -1127,48 +1181,28 @@ class Monster {
   String? get name =>
       const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
   List<int>? get inventory =>
-      const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 14);
   Color get color =>
       Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));
   AnyTypeId? get testType => AnyTypeId._createOrNull(
-    const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18),
-  );
-  dynamic get test {
-    switch (testType?.value) {
-      case 1:
-        return Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);
-      case 2:
-        return TestSimpleTableWithEnum.reader.vTableGetNullable(
-          _bc,
-          _bcOffset,
-          20,
-        );
-      case 3:
-        return my_game_example2.Monster.reader.vTableGetNullable(
-          _bc,
-          _bcOffset,
-          20,
-        );
-      default:
-        return null;
-    }
-  }
-
+        const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18),
+      );
+  dynamic get test => _AnyReader(testType).vTableGetNullable(_bc, _bcOffset, 20);
   List<Test>? get test4 => const fb.ListReader<Test>(
-    Test.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 22);
+        Test.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 22);
   List<String>? get testarrayofstring => const fb.ListReader<String>(
-    fb.StringReader(),
-  ).vTableGetNullable(_bc, _bcOffset, 24);
+        fb.StringReader(),
+      ).vTableGetNullable(_bc, _bcOffset, 24);
 
   ///  an example documentation comment: this will end up in the generated code
   ///  multiline too
   List<Monster>? get testarrayoftables => const fb.ListReader<Monster>(
-    Monster.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 26);
+        Monster.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 26);
   Monster? get enemy => Monster.reader.vTableGetNullable(_bc, _bcOffset, 28);
   List<int>? get testnestedflatbuffer =>
-      const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 30);
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 30);
   Stat? get testempty => Stat.reader.vTableGetNullable(_bc, _bcOffset, 32);
   bool get testbool =>
       const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);
@@ -1189,8 +1223,8 @@ class Monster {
   int get testhashu64Fnv1a =>
       const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);
   List<bool>? get testarrayofbools => const fb.ListReader<bool>(
-    fb.BoolReader(),
-  ).vTableGetNullable(_bc, _bcOffset, 52);
+        fb.BoolReader(),
+      ).vTableGetNullable(_bc, _bcOffset, 52);
   double get testf =>
       const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);
   double get testf2 =>
@@ -1198,32 +1232,32 @@ class Monster {
   double get testf3 =>
       const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);
   List<String>? get testarrayofstring2 => const fb.ListReader<String>(
-    fb.StringReader(),
-  ).vTableGetNullable(_bc, _bcOffset, 60);
+        fb.StringReader(),
+      ).vTableGetNullable(_bc, _bcOffset, 60);
   List<Ability>? get testarrayofsortedstruct => const fb.ListReader<Ability>(
-    Ability.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 62);
+        Ability.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 62);
   List<int>? get flex =>
-      const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 64);
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 64);
   List<Test>? get test5 => const fb.ListReader<Test>(
-    Test.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 66);
+        Test.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 66);
   List<int>? get vectorOfLongs => const fb.ListReader<int>(
-    fb.Int64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 68);
+        fb.Int64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 68);
   List<double>? get vectorOfDoubles => const fb.ListReader<double>(
-    fb.Float64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 70);
+        fb.Float64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 70);
   my_game.InParentNamespace? get parentNamespaceTest =>
       my_game.InParentNamespace.reader.vTableGetNullable(_bc, _bcOffset, 72);
   List<Referrable>? get vectorOfReferrables => const fb.ListReader<Referrable>(
-    Referrable.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 74);
+        Referrable.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 74);
   int get singleWeakReference =>
       const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);
   List<int>? get vectorOfWeakReferences => const fb.ListReader<int>(
-    fb.Uint64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 78);
+        fb.Uint64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 78);
   List<Referrable>? get vectorOfStrongReferrables =>
       const fb.ListReader<Referrable>(
         Referrable.reader,
@@ -1231,72 +1265,39 @@ class Monster {
   int get coOwningReference =>
       const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);
   List<int>? get vectorOfCoOwningReferences => const fb.ListReader<int>(
-    fb.Uint64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 84);
+        fb.Uint64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 84);
   int get nonOwningReference =>
       const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);
   List<int>? get vectorOfNonOwningReferences => const fb.ListReader<int>(
-    fb.Uint64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 88);
+        fb.Uint64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 88);
   AnyUniqueAliasesTypeId? get anyUniqueType =>
       AnyUniqueAliasesTypeId._createOrNull(
         const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 90),
       );
-  dynamic get anyUnique {
-    switch (anyUniqueType?.value) {
-      case 1:
-        return Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);
-      case 2:
-        return TestSimpleTableWithEnum.reader.vTableGetNullable(
-          _bc,
-          _bcOffset,
-          92,
-        );
-      case 3:
-        return my_game_example2.Monster.reader.vTableGetNullable(
-          _bc,
-          _bcOffset,
-          92,
-        );
-      default:
-        return null;
-    }
-  }
-
+  dynamic get anyUnique => _AnyUniqueAliasesReader(anyUniqueType).vTableGetNullable(_bc, _bcOffset, 92);
   AnyAmbiguousAliasesTypeId? get anyAmbiguousType =>
       AnyAmbiguousAliasesTypeId._createOrNull(
         const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 94),
       );
-  dynamic get anyAmbiguous {
-    switch (anyAmbiguousType?.value) {
-      case 1:
-        return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      case 2:
-        return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      case 3:
-        return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      default:
-        return null;
-    }
-  }
-
+  dynamic get anyAmbiguous => _AnyAmbiguousAliasesReader(anyAmbiguousType).vTableGetNullable(_bc, _bcOffset, 96);
   List<Color>? get vectorOfEnums => const fb.ListReader<Color>(
-    Color.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 98);
+        Color.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 98);
   Race get signedEnum =>
       Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
-  List<int>? get testrequirednestedflatbuffer =>
-      const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 102);
+  List<int>? get testrequirednestedflatbuffer => const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 102);
   List<Stat>? get scalarKeySortedTables => const fb.ListReader<Stat>(
-    Stat.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 104);
+        Stat.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 104);
   Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
   LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(
-    const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0),
-  );
+        const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0),
+      );
   LongEnum get longEnumNormalDefault => LongEnum.fromValue(
-    const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2),
-  );
+        const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2),
+      );
   double get nanDefault =>
       const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
   double get infDefault =>
@@ -1308,17 +1309,17 @@ class Monster {
   double get positiveInfinityDefault =>
       const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
   double get negativeInfDefault => const fb.Float32Reader().vTableGet(
-    _bc,
-    _bcOffset,
-    122,
-    double.negativeInfinity,
-  );
+        _bc,
+        _bcOffset,
+        122,
+        double.negativeInfinity,
+      );
   double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(
-    _bc,
-    _bcOffset,
-    124,
-    double.negativeInfinity,
-  );
+        _bc,
+        _bcOffset,
+        124,
+        double.negativeInfinity,
+      );
   double get doubleInfDefault =>
       const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
 
@@ -1335,7 +1336,7 @@ class Monster {
     inventory: inventory?.toList(),
     color: color,
     testType: testType,
-    test: test?.unpack(),
+    test: test is String ? test : test?.unpack(),
     test4: test4?.map((e) => e.unpack()).toList(),
     testarrayofstring: testarrayofstring?.toList(),
     testarrayoftables: testarrayoftables?.map((e) => e.unpack()).toList(),
@@ -1371,9 +1372,9 @@ class Monster {
     nonOwningReference: nonOwningReference,
     vectorOfNonOwningReferences: vectorOfNonOwningReferences?.toList(),
     anyUniqueType: anyUniqueType,
-    anyUnique: anyUnique?.unpack(),
+    anyUnique: anyUnique is String ? anyUnique : anyUnique?.unpack(),
     anyAmbiguousType: anyAmbiguousType,
-    anyAmbiguous: anyAmbiguous?.unpack(),
+    anyAmbiguous: anyAmbiguous is String ? anyAmbiguous : anyAmbiguous?.unpack(),
     vectorOfEnums: vectorOfEnums?.toList(),
     signedEnum: signedEnum,
     testrequirednestedflatbuffer: testrequirednestedflatbuffer?.toList(),
@@ -1531,10 +1532,9 @@ class MonsterT implements fb.Packable {
   @override
   int pack(fb.Builder fbBuilder) {
     final int? nameOffset = name == null ? null : fbBuilder.writeString(name!);
-    final int? inventoryOffset = inventory == null
-        ? null
-        : fbBuilder.writeListUint8(inventory!);
-    final int? testOffset = test?.pack(fbBuilder);
+    final int? inventoryOffset =
+        inventory == null ? null : fbBuilder.writeListUint8(inventory!);
+    final int? testOffset = test is String ? fbBuilder.writeString(test) : test?.pack(fbBuilder);
     int? test4Offset;
     if (test4 != null) {
       for (var e in test4!.reversed) {
@@ -1574,9 +1574,8 @@ class MonsterT implements fb.Packable {
         testarrayofsortedstruct!.length,
       );
     }
-    final int? flexOffset = flex == null
-        ? null
-        : fbBuilder.writeListUint8(flex!);
+    final int? flexOffset =
+        flex == null ? null : fbBuilder.writeListUint8(flex!);
     int? test5Offset;
     if (test5 != null) {
       for (var e in test5!.reversed) {
@@ -1584,9 +1583,8 @@ class MonsterT implements fb.Packable {
       }
       test5Offset = fbBuilder.endStructVector(test5!.length);
     }
-    final int? vectorOfLongsOffset = vectorOfLongs == null
-        ? null
-        : fbBuilder.writeListInt64(vectorOfLongs!);
+    final int? vectorOfLongsOffset =
+        vectorOfLongs == null ? null : fbBuilder.writeListInt64(vectorOfLongs!);
     final int? vectorOfDoublesOffset = vectorOfDoubles == null
         ? null
         : fbBuilder.writeListFloat64(vectorOfDoubles!);
@@ -1599,29 +1597,29 @@ class MonsterT implements fb.Packable {
     final int? vectorOfWeakReferencesOffset = vectorOfWeakReferences == null
         ? null
         : fbBuilder.writeListUint64(vectorOfWeakReferences!);
-    final int? vectorOfStrongReferrablesOffset =
-        vectorOfStrongReferrables == null
+    final int? vectorOfStrongReferrablesOffset = vectorOfStrongReferrables ==
+            null
         ? null
         : fbBuilder.writeList(
             vectorOfStrongReferrables!.map((b) => b.pack(fbBuilder)).toList(),
           );
     final int? vectorOfCoOwningReferencesOffset =
         vectorOfCoOwningReferences == null
-        ? null
-        : fbBuilder.writeListUint64(vectorOfCoOwningReferences!);
+            ? null
+            : fbBuilder.writeListUint64(vectorOfCoOwningReferences!);
     final int? vectorOfNonOwningReferencesOffset =
         vectorOfNonOwningReferences == null
-        ? null
-        : fbBuilder.writeListUint64(vectorOfNonOwningReferences!);
-    final int? anyUniqueOffset = anyUnique?.pack(fbBuilder);
-    final int? anyAmbiguousOffset = anyAmbiguous?.pack(fbBuilder);
+            ? null
+            : fbBuilder.writeListUint64(vectorOfNonOwningReferences!);
+    final int? anyUniqueOffset = anyUnique is String ? fbBuilder.writeString(anyUnique) : anyUnique?.pack(fbBuilder);
+    final int? anyAmbiguousOffset = anyAmbiguous is String ? fbBuilder.writeString(anyAmbiguous) : anyAmbiguous?.pack(fbBuilder);
     final int? vectorOfEnumsOffset = vectorOfEnums == null
         ? null
         : fbBuilder.writeListUint8(vectorOfEnums!.map((f) => f.value).toList());
     final int? testrequirednestedflatbufferOffset =
         testrequirednestedflatbuffer == null
-        ? null
-        : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
+            ? null
+            : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
     final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null
         ? null
         : fbBuilder.writeList(
@@ -2154,81 +2152,78 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     double? negativeInfDefault,
     double? negativeInfinityDefault,
     double? doubleInfDefault,
-  }) : _pos = pos,
-       _mana = mana,
-       _hp = hp,
-       _name = name,
-       _inventory = inventory,
-       _color = color,
-       _testType = testType,
-       _test = test,
-       _test4 = test4,
-       _testarrayofstring = testarrayofstring,
-       _testarrayoftables = testarrayoftables,
-       _enemy = enemy,
-       _testnestedflatbuffer = testnestedflatbuffer,
-       _testempty = testempty,
-       _testbool = testbool,
-       _testhashs32Fnv1 = testhashs32Fnv1,
-       _testhashu32Fnv1 = testhashu32Fnv1,
-       _testhashs64Fnv1 = testhashs64Fnv1,
-       _testhashu64Fnv1 = testhashu64Fnv1,
-       _testhashs32Fnv1a = testhashs32Fnv1a,
-       _testhashu32Fnv1a = testhashu32Fnv1a,
-       _testhashs64Fnv1a = testhashs64Fnv1a,
-       _testhashu64Fnv1a = testhashu64Fnv1a,
-       _testarrayofbools = testarrayofbools,
-       _testf = testf,
-       _testf2 = testf2,
-       _testf3 = testf3,
-       _testarrayofstring2 = testarrayofstring2,
-       _testarrayofsortedstruct = testarrayofsortedstruct,
-       _flex = flex,
-       _test5 = test5,
-       _vectorOfLongs = vectorOfLongs,
-       _vectorOfDoubles = vectorOfDoubles,
-       _parentNamespaceTest = parentNamespaceTest,
-       _vectorOfReferrables = vectorOfReferrables,
-       _singleWeakReference = singleWeakReference,
-       _vectorOfWeakReferences = vectorOfWeakReferences,
-       _vectorOfStrongReferrables = vectorOfStrongReferrables,
-       _coOwningReference = coOwningReference,
-       _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
-       _nonOwningReference = nonOwningReference,
-       _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
-       _anyUniqueType = anyUniqueType,
-       _anyUnique = anyUnique,
-       _anyAmbiguousType = anyAmbiguousType,
-       _anyAmbiguous = anyAmbiguous,
-       _vectorOfEnums = vectorOfEnums,
-       _signedEnum = signedEnum,
-       _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
-       _scalarKeySortedTables = scalarKeySortedTables,
-       _nativeInline = nativeInline,
-       _longEnumNonEnumDefault = longEnumNonEnumDefault,
-       _longEnumNormalDefault = longEnumNormalDefault,
-       _nanDefault = nanDefault,
-       _infDefault = infDefault,
-       _positiveInfDefault = positiveInfDefault,
-       _infinityDefault = infinityDefault,
-       _positiveInfinityDefault = positiveInfinityDefault,
-       _negativeInfDefault = negativeInfDefault,
-       _negativeInfinityDefault = negativeInfinityDefault,
-       _doubleInfDefault = doubleInfDefault;
+  })  : _pos = pos,
+        _mana = mana,
+        _hp = hp,
+        _name = name,
+        _inventory = inventory,
+        _color = color,
+        _testType = testType,
+        _test = test,
+        _test4 = test4,
+        _testarrayofstring = testarrayofstring,
+        _testarrayoftables = testarrayoftables,
+        _enemy = enemy,
+        _testnestedflatbuffer = testnestedflatbuffer,
+        _testempty = testempty,
+        _testbool = testbool,
+        _testhashs32Fnv1 = testhashs32Fnv1,
+        _testhashu32Fnv1 = testhashu32Fnv1,
+        _testhashs64Fnv1 = testhashs64Fnv1,
+        _testhashu64Fnv1 = testhashu64Fnv1,
+        _testhashs32Fnv1a = testhashs32Fnv1a,
+        _testhashu32Fnv1a = testhashu32Fnv1a,
+        _testhashs64Fnv1a = testhashs64Fnv1a,
+        _testhashu64Fnv1a = testhashu64Fnv1a,
+        _testarrayofbools = testarrayofbools,
+        _testf = testf,
+        _testf2 = testf2,
+        _testf3 = testf3,
+        _testarrayofstring2 = testarrayofstring2,
+        _testarrayofsortedstruct = testarrayofsortedstruct,
+        _flex = flex,
+        _test5 = test5,
+        _vectorOfLongs = vectorOfLongs,
+        _vectorOfDoubles = vectorOfDoubles,
+        _parentNamespaceTest = parentNamespaceTest,
+        _vectorOfReferrables = vectorOfReferrables,
+        _singleWeakReference = singleWeakReference,
+        _vectorOfWeakReferences = vectorOfWeakReferences,
+        _vectorOfStrongReferrables = vectorOfStrongReferrables,
+        _coOwningReference = coOwningReference,
+        _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
+        _nonOwningReference = nonOwningReference,
+        _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
+        _anyUniqueType = anyUniqueType,
+        _anyUnique = anyUnique,
+        _anyAmbiguousType = anyAmbiguousType,
+        _anyAmbiguous = anyAmbiguous,
+        _vectorOfEnums = vectorOfEnums,
+        _signedEnum = signedEnum,
+        _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
+        _scalarKeySortedTables = scalarKeySortedTables,
+        _nativeInline = nativeInline,
+        _longEnumNonEnumDefault = longEnumNonEnumDefault,
+        _longEnumNormalDefault = longEnumNormalDefault,
+        _nanDefault = nanDefault,
+        _infDefault = infDefault,
+        _positiveInfDefault = positiveInfDefault,
+        _infinityDefault = infinityDefault,
+        _positiveInfinityDefault = positiveInfinityDefault,
+        _negativeInfDefault = negativeInfDefault,
+        _negativeInfinityDefault = negativeInfinityDefault,
+        _doubleInfDefault = doubleInfDefault;
 
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
-    final int? nameOffset = _name == null
-        ? null
-        : fbBuilder.writeString(_name!);
-    final int? inventoryOffset = _inventory == null
-        ? null
-        : fbBuilder.writeListUint8(_inventory!);
-    final int? testOffset = _test?.getOrCreateOffset(fbBuilder);
-    final int? test4Offset = _test4 == null
-        ? null
-        : fbBuilder.writeListOfStructs(_test4!);
+    final int? nameOffset =
+        _name == null ? null : fbBuilder.writeString(_name!);
+    final int? inventoryOffset =
+        _inventory == null ? null : fbBuilder.writeListUint8(_inventory!);
+    final int? testOffset = _test is String ? fbBuilder.writeString(_test) : _test?.getOrCreateOffset(fbBuilder);
+    final int? test4Offset =
+        _test4 == null ? null : fbBuilder.writeListOfStructs(_test4!);
     final int? testarrayofstringOffset = _testarrayofstring == null
         ? null
         : fbBuilder.writeList(
@@ -2257,20 +2252,18 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     final int? testarrayofsortedstructOffset = _testarrayofsortedstruct == null
         ? null
         : fbBuilder.writeListOfStructs(_testarrayofsortedstruct!);
-    final int? flexOffset = _flex == null
-        ? null
-        : fbBuilder.writeListUint8(_flex!);
-    final int? test5Offset = _test5 == null
-        ? null
-        : fbBuilder.writeListOfStructs(_test5!);
+    final int? flexOffset =
+        _flex == null ? null : fbBuilder.writeListUint8(_flex!);
+    final int? test5Offset =
+        _test5 == null ? null : fbBuilder.writeListOfStructs(_test5!);
     final int? vectorOfLongsOffset = _vectorOfLongs == null
         ? null
         : fbBuilder.writeListInt64(_vectorOfLongs!);
     final int? vectorOfDoublesOffset = _vectorOfDoubles == null
         ? null
         : fbBuilder.writeListFloat64(_vectorOfDoubles!);
-    final int? parentNamespaceTestOffset = _parentNamespaceTest
-        ?.getOrCreateOffset(fbBuilder);
+    final int? parentNamespaceTestOffset =
+        _parentNamespaceTest?.getOrCreateOffset(fbBuilder);
     final int? vectorOfReferrablesOffset = _vectorOfReferrables == null
         ? null
         : fbBuilder.writeList(
@@ -2283,22 +2276,22 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
         : fbBuilder.writeListUint64(_vectorOfWeakReferences!);
     final int? vectorOfStrongReferrablesOffset =
         _vectorOfStrongReferrables == null
-        ? null
-        : fbBuilder.writeList(
-            _vectorOfStrongReferrables!
-                .map((b) => b.getOrCreateOffset(fbBuilder))
-                .toList(),
-          );
+            ? null
+            : fbBuilder.writeList(
+                _vectorOfStrongReferrables!
+                    .map((b) => b.getOrCreateOffset(fbBuilder))
+                    .toList(),
+              );
     final int? vectorOfCoOwningReferencesOffset =
         _vectorOfCoOwningReferences == null
-        ? null
-        : fbBuilder.writeListUint64(_vectorOfCoOwningReferences!);
+            ? null
+            : fbBuilder.writeListUint64(_vectorOfCoOwningReferences!);
     final int? vectorOfNonOwningReferencesOffset =
         _vectorOfNonOwningReferences == null
-        ? null
-        : fbBuilder.writeListUint64(_vectorOfNonOwningReferences!);
-    final int? anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);
-    final int? anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);
+            ? null
+            : fbBuilder.writeListUint64(_vectorOfNonOwningReferences!);
+    final int? anyUniqueOffset = _anyUnique is String ? fbBuilder.writeString(_anyUnique) : _anyUnique?.getOrCreateOffset(fbBuilder);
+    final int? anyAmbiguousOffset = _anyAmbiguous is String ? fbBuilder.writeString(_anyAmbiguous) : _anyAmbiguous?.getOrCreateOffset(fbBuilder);
     final int? vectorOfEnumsOffset = _vectorOfEnums == null
         ? null
         : fbBuilder.writeListUint8(
@@ -2306,8 +2299,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
           );
     final int? testrequirednestedflatbufferOffset =
         _testrequirednestedflatbuffer == null
-        ? null
-        : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
+            ? null
+            : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
     final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null
         ? null
         : fbBuilder.writeList(
@@ -2415,11 +2408,10 @@ class TypeAliases {
   int get u64 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 18, 0);
   double get f32 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 20, 0.0);
   double get f64 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 22, 0.0);
-  List<int>? get v8 =>
-      const fb.Int8ListReader().vTableGetNullable(_bc, _bcOffset, 24);
+  List<int>? get v8 => const fb.ListReader<int>(fb.Int8Reader()).vTableGetNullable(_bc, _bcOffset, 24);
   List<double>? get vf64 => const fb.ListReader<double>(
-    fb.Float64Reader(),
-  ).vTableGetNullable(_bc, _bcOffset, 26);
+        fb.Float64Reader(),
+      ).vTableGetNullable(_bc, _bcOffset, 26);
 
   @override
   String toString() {
@@ -2479,9 +2471,8 @@ class TypeAliasesT implements fb.Packable {
   @override
   int pack(fb.Builder fbBuilder) {
     final int? v8Offset = v8 == null ? null : fbBuilder.writeListInt8(v8!);
-    final int? vf64Offset = vf64 == null
-        ? null
-        : fbBuilder.writeListFloat64(vf64!);
+    final int? vf64Offset =
+        vf64 == null ? null : fbBuilder.writeListFloat64(vf64!);
     fbBuilder.startTable(12);
     fbBuilder.addInt8(0, i8);
     fbBuilder.addUint8(1, u8);
@@ -2613,26 +2604,25 @@ class TypeAliasesObjectBuilder extends fb.ObjectBuilder {
     double? f64,
     List<int>? v8,
     List<double>? vf64,
-  }) : _i8 = i8,
-       _u8 = u8,
-       _i16 = i16,
-       _u16 = u16,
-       _i32 = i32,
-       _u32 = u32,
-       _i64 = i64,
-       _u64 = u64,
-       _f32 = f32,
-       _f64 = f64,
-       _v8 = v8,
-       _vf64 = vf64;
+  })  : _i8 = i8,
+        _u8 = u8,
+        _i16 = i16,
+        _u16 = u16,
+        _i32 = i32,
+        _u32 = u32,
+        _i64 = i64,
+        _u64 = u64,
+        _f32 = f32,
+        _f64 = f64,
+        _v8 = v8,
+        _vf64 = vf64;
 
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
     final int? v8Offset = _v8 == null ? null : fbBuilder.writeListInt8(_v8!);
-    final int? vf64Offset = _vf64 == null
-        ? null
-        : fbBuilder.writeListFloat64(_vf64!);
+    final int? vf64Offset =
+        _vf64 == null ? null : fbBuilder.writeListFloat64(_vf64!);
     fbBuilder.startTable(12);
     fbBuilder.addInt8(0, _i8);
     fbBuilder.addUint8(1, _u8);
diff --git a/dart/test/union_vector_generated.dart b/dart/test/union_vector_generated.dart
new file mode 100644
index 00000000000..1c287bd6eb7
--- /dev/null
+++ b/dart/test/union_vector_generated.dart
@@ -0,0 +1,722 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+
+import 'dart:typed_data' show Uint8List;
+import 'package:flat_buffers/flat_buffers.dart' as fb;
+
+
+enum CharacterTypeId {
+  NONE(0),
+  MuLan(1),
+  Rapunzel(2),
+  Belle(3),
+  BookFan(4),
+  Other(5),
+  Unused(6);
+
+  final int value;
+  const CharacterTypeId(this.value);
+
+  factory CharacterTypeId.fromValue(int value) {
+    switch (value) {
+      case 0: return CharacterTypeId.NONE;
+      case 1: return CharacterTypeId.MuLan;
+      case 2: return CharacterTypeId.Rapunzel;
+      case 3: return CharacterTypeId.Belle;
+      case 4: return CharacterTypeId.BookFan;
+      case 5: return CharacterTypeId.Other;
+      case 6: return CharacterTypeId.Unused;
+      default: throw StateError('Invalid value $value for bit flag enum');
+    }
+  }
+
+  static CharacterTypeId? _createOrNull(int? value) =>
+      value == null ? null : CharacterTypeId.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 6;
+  static const fb.Reader<CharacterTypeId> reader = _CharacterTypeIdReader();
+}
+
+class _CharacterTypeIdReader extends fb.Reader<CharacterTypeId> {
+  const _CharacterTypeIdReader();
+
+  @override
+  int get size => 1;
+
+  @override
+  CharacterTypeId read(fb.BufferContext bc, int offset) =>
+      CharacterTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+}
+
+class _CharacterReader extends fb.UnionReader {
+  _CharacterReader(CharacterTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(CharacterTypeId? type) {
+    switch (type?.value) {
+      case 1: return Attacker.reader;
+      case 2: return Rapunzel.reader;
+      case 3: return BookReader.reader;
+      case 4: return BookReader.reader;
+      case 5: return fb.StringReader();
+      case 6: return fb.StringReader();
+      default: return null;
+    }
+  }
+}
+
+enum GadgetTypeId {
+  NONE(0),
+  FallingTub(1),
+  HandFan(2);
+
+  final int value;
+  const GadgetTypeId(this.value);
+
+  factory GadgetTypeId.fromValue(int value) {
+    switch (value) {
+      case 0: return GadgetTypeId.NONE;
+      case 1: return GadgetTypeId.FallingTub;
+      case 2: return GadgetTypeId.HandFan;
+      default: throw StateError('Invalid value $value for bit flag enum');
+    }
+  }
+
+  static GadgetTypeId? _createOrNull(int? value) =>
+      value == null ? null : GadgetTypeId.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 2;
+  static const fb.Reader<GadgetTypeId> reader = _GadgetTypeIdReader();
+}
+
+class _GadgetTypeIdReader extends fb.Reader<GadgetTypeId> {
+  const _GadgetTypeIdReader();
+
+  @override
+  int get size => 1;
+
+  @override
+  GadgetTypeId read(fb.BufferContext bc, int offset) =>
+      GadgetTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+}
+
+class _GadgetReader extends fb.UnionReader {
+  _GadgetReader(GadgetTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(GadgetTypeId? type) {
+    switch (type?.value) {
+      case 1: return FallingTub.reader;
+      case 2: return HandFan.reader;
+      default: return null;
+    }
+  }
+}
+
+class Attacker {
+  Attacker._(this._bc, this._bcOffset);
+  factory Attacker(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Attacker> reader = _AttackerReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get swordAttackDamage => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0);
+
+  @override
+  String toString() {
+    return 'Attacker{swordAttackDamage: ${swordAttackDamage}}';
+  }
+
+  AttackerT unpack() => AttackerT(
+      swordAttackDamage: swordAttackDamage);
+
+  static int pack(fb.Builder fbBuilder, AttackerT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class AttackerT implements fb.Packable {
+  int swordAttackDamage;
+
+  AttackerT({
+      this.swordAttackDamage = 0});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, swordAttackDamage);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'AttackerT{swordAttackDamage: ${swordAttackDamage}}';
+  }
+}
+
+class _AttackerReader extends fb.TableReader<Attacker> {
+  const _AttackerReader();
+
+  @override
+  Attacker createObject(fb.BufferContext bc, int offset) => 
+    Attacker._(bc, offset);
+}
+
+class AttackerBuilder {
+  AttackerBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(1);
+  }
+
+  int addSwordAttackDamage(int? swordAttackDamage) {
+    fbBuilder.addInt32(0, swordAttackDamage);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class AttackerObjectBuilder extends fb.ObjectBuilder {
+  final int? _swordAttackDamage;
+
+  AttackerObjectBuilder({
+    int? swordAttackDamage,
+  })
+      : _swordAttackDamage = swordAttackDamage;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, _swordAttackDamage);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class Rapunzel {
+  Rapunzel._(this._bc, this._bcOffset);
+
+  static const fb.Reader<Rapunzel> reader = _RapunzelReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get hairLength => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'Rapunzel{hairLength: ${hairLength}}';
+  }
+
+  RapunzelT unpack() => RapunzelT(
+      hairLength: hairLength);
+
+  static int pack(fb.Builder fbBuilder, RapunzelT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class RapunzelT implements fb.Packable {
+  int hairLength;
+
+  RapunzelT({
+      required this.hairLength});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(hairLength);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'RapunzelT{hairLength: ${hairLength}}';
+  }
+}
+
+class _RapunzelReader extends fb.StructReader<Rapunzel> {
+  const _RapunzelReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  Rapunzel createObject(fb.BufferContext bc, int offset) => 
+    Rapunzel._(bc, offset);
+}
+
+class RapunzelBuilder {
+  RapunzelBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int hairLength) {
+    fbBuilder.putInt32(hairLength);
+    return fbBuilder.offset;
+  }
+
+}
+
+class RapunzelObjectBuilder extends fb.ObjectBuilder {
+  final int _hairLength;
+
+  RapunzelObjectBuilder({
+    required int hairLength,
+  })
+      : _hairLength = hairLength;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_hairLength);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class BookReader {
+  BookReader._(this._bc, this._bcOffset);
+
+  static const fb.Reader<BookReader> reader = _BookReaderReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get booksRead => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'BookReader{booksRead: ${booksRead}}';
+  }
+
+  BookReaderT unpack() => BookReaderT(
+      booksRead: booksRead);
+
+  static int pack(fb.Builder fbBuilder, BookReaderT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class BookReaderT implements fb.Packable {
+  int booksRead;
+
+  BookReaderT({
+      required this.booksRead});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(booksRead);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'BookReaderT{booksRead: ${booksRead}}';
+  }
+}
+
+class _BookReaderReader extends fb.StructReader<BookReader> {
+  const _BookReaderReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  BookReader createObject(fb.BufferContext bc, int offset) => 
+    BookReader._(bc, offset);
+}
+
+class BookReaderBuilder {
+  BookReaderBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int booksRead) {
+    fbBuilder.putInt32(booksRead);
+    return fbBuilder.offset;
+  }
+
+}
+
+class BookReaderObjectBuilder extends fb.ObjectBuilder {
+  final int _booksRead;
+
+  BookReaderObjectBuilder({
+    required int booksRead,
+  })
+      : _booksRead = booksRead;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_booksRead);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class FallingTub {
+  FallingTub._(this._bc, this._bcOffset);
+
+  static const fb.Reader<FallingTub> reader = _FallingTubReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get weight => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'FallingTub{weight: ${weight}}';
+  }
+
+  FallingTubT unpack() => FallingTubT(
+      weight: weight);
+
+  static int pack(fb.Builder fbBuilder, FallingTubT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class FallingTubT implements fb.Packable {
+  int weight;
+
+  FallingTubT({
+      required this.weight});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(weight);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'FallingTubT{weight: ${weight}}';
+  }
+}
+
+class _FallingTubReader extends fb.StructReader<FallingTub> {
+  const _FallingTubReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  FallingTub createObject(fb.BufferContext bc, int offset) => 
+    FallingTub._(bc, offset);
+}
+
+class FallingTubBuilder {
+  FallingTubBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int weight) {
+    fbBuilder.putInt32(weight);
+    return fbBuilder.offset;
+  }
+
+}
+
+class FallingTubObjectBuilder extends fb.ObjectBuilder {
+  final int _weight;
+
+  FallingTubObjectBuilder({
+    required int weight,
+  })
+      : _weight = weight;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_weight);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class HandFan {
+  HandFan._(this._bc, this._bcOffset);
+  factory HandFan(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<HandFan> reader = _HandFanReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get length => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0);
+
+  @override
+  String toString() {
+    return 'HandFan{length: ${length}}';
+  }
+
+  HandFanT unpack() => HandFanT(
+      length: length);
+
+  static int pack(fb.Builder fbBuilder, HandFanT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class HandFanT implements fb.Packable {
+  int length;
+
+  HandFanT({
+      this.length = 0});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, length);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'HandFanT{length: ${length}}';
+  }
+}
+
+class _HandFanReader extends fb.TableReader<HandFan> {
+  const _HandFanReader();
+
+  @override
+  HandFan createObject(fb.BufferContext bc, int offset) => 
+    HandFan._(bc, offset);
+}
+
+class HandFanBuilder {
+  HandFanBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(1);
+  }
+
+  int addLength(int? length) {
+    fbBuilder.addInt32(0, length);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class HandFanObjectBuilder extends fb.ObjectBuilder {
+  final int? _length;
+
+  HandFanObjectBuilder({
+    int? length,
+  })
+      : _length = length;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, _length);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class Movie {
+  Movie._(this._bc, this._bcOffset);
+  factory Movie(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Movie> reader = _MovieReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  CharacterTypeId? get mainCharacterType => CharacterTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 4));
+  dynamic get mainCharacter => _CharacterReader(mainCharacterType).vTableGetNullable(_bc, _bcOffset, 6);
+  List<CharacterTypeId>? get charactersType => const fb.ListReader<CharacterTypeId>(CharacterTypeId.reader).vTableGetNullable(_bc, _bcOffset, 8);
+  List<dynamic>? get characters => fb.UnionListReader((index) => _CharacterReader(charactersType?[index])).vTableGetNullable(_bc, _bcOffset, 10);
+
+  @override
+  String toString() {
+    return 'Movie{mainCharacterType: ${mainCharacterType}, mainCharacter: ${mainCharacter}, charactersType: ${charactersType}, characters: ${characters}}';
+  }
+
+  MovieT unpack() => MovieT(
+      mainCharacterType: mainCharacterType,
+      mainCharacter: mainCharacter is String ? mainCharacter : mainCharacter?.unpack(),
+      charactersType: charactersType?.toList(),
+      characters: characters?.map((e) => e is String ? e : e.unpack()).toList());
+
+  static int pack(fb.Builder fbBuilder, MovieT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class MovieT implements fb.Packable {
+  CharacterTypeId? mainCharacterType;
+  dynamic mainCharacter;
+  List<CharacterTypeId>? charactersType;
+  List<dynamic>? characters;
+
+  MovieT({
+      this.mainCharacterType,
+      this.mainCharacter,
+      this.charactersType,
+      this.characters});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    final int? mainCharacterOffset = mainCharacter is String ? fbBuilder.writeString(mainCharacter) : mainCharacter?.pack(fbBuilder);
+    final int? charactersTypeOffset = charactersType == null ? null
+        : fbBuilder.writeListUint8(charactersType!.map((f) => f.value).toList());
+    final int? charactersOffset = characters == null ? null
+        : fbBuilder.writeList(characters!.map<int>((u) => u is String ? fbBuilder.writeString(u) : u.pack(fbBuilder)).toList());
+    fbBuilder.startTable(4);
+    fbBuilder.addUint8(0, mainCharacterType?.value);
+    fbBuilder.addOffset(1, mainCharacterOffset);
+    fbBuilder.addOffset(2, charactersTypeOffset);
+    fbBuilder.addOffset(3, charactersOffset);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'MovieT{mainCharacterType: ${mainCharacterType}, mainCharacter: ${mainCharacter}, charactersType: ${charactersType}, characters: ${characters}}';
+  }
+}
+
+class _MovieReader extends fb.TableReader<Movie> {
+  const _MovieReader();
+
+  @override
+  Movie createObject(fb.BufferContext bc, int offset) => 
+    Movie._(bc, offset);
+}
+
+class MovieBuilder {
+  MovieBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(4);
+  }
+
+  int addMainCharacterType(CharacterTypeId? mainCharacterType) {
+    fbBuilder.addUint8(0, mainCharacterType?.value);
+    return fbBuilder.offset;
+  }
+  int addMainCharacterOffset(int? offset) {
+    fbBuilder.addOffset(1, offset);
+    return fbBuilder.offset;
+  }
+  int addCharactersTypeOffset(int? offset) {
+    fbBuilder.addOffset(2, offset);
+    return fbBuilder.offset;
+  }
+  int addCharactersOffset(int? offset) {
+    fbBuilder.addOffset(3, offset);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class MovieObjectBuilder extends fb.ObjectBuilder {
+  final CharacterTypeId? _mainCharacterType;
+  final dynamic _mainCharacter;
+  final List<CharacterTypeId>? _charactersType;
+  final List<dynamic>? _characters;
+
+  MovieObjectBuilder({
+    CharacterTypeId? mainCharacterType,
+    dynamic mainCharacter,
+    List<CharacterTypeId>? charactersType,
+    List<dynamic>? characters,
+  })
+      : _mainCharacterType = mainCharacterType,
+        _mainCharacter = mainCharacter,
+        _charactersType = charactersType,
+        _characters = characters;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    final int? mainCharacterOffset = _mainCharacter is String ? fbBuilder.writeString(_mainCharacter) : _mainCharacter?.getOrCreateOffset(fbBuilder);
+    final int? charactersTypeOffset = _charactersType == null ? null
+        : fbBuilder.writeListUint8(_charactersType!.map((f) => f.value).toList());
+    final int? charactersOffset = _characters == null ? null
+        : fbBuilder.writeList(_characters!.map<int>((u) => u is String ? fbBuilder.writeString(u) : u.getOrCreateOffset(fbBuilder)).toList());
+    fbBuilder.startTable(4);
+    fbBuilder.addUint8(0, _mainCharacterType?.value);
+    fbBuilder.addOffset(1, mainCharacterOffset);
+    fbBuilder.addOffset(2, charactersTypeOffset);
+    fbBuilder.addOffset(3, charactersOffset);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
diff --git a/scripts/generate_code.py b/scripts/generate_code.py
index c1a4448c06d..fec7022992d 100755
--- a/scripts/generate_code.py
+++ b/scripts/generate_code.py
@@ -240,7 +240,7 @@ def glob(path, pattern):
 )
 
 flatc(
-    BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS,
+    BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS + DART_OPTS,
     prefix="union_vector",
     schema="union_vector/union_vector.fbs",
 )
@@ -443,6 +443,11 @@ def glob(path, pattern):
 dictionary_lookup_schema = "dictionary_lookup.fbs"
 flatc(["--java", "--kotlin"], schema=dictionary_lookup_schema)
 
+flatc(
+    NO_INCL_OPTS + DART_OPTS + ["-o", "../dart/test"],
+    schema="union_vector/union_vector.fbs",
+)
+
 # Swift Tests
 swift_prefix = "swift/Tests/Flatbuffers"
 flatc(
diff --git a/src/idl_gen_dart.cpp b/src/idl_gen_dart.cpp
index 589e5d91fb4..0b47d90e545 100644
--- a/src/idl_gen_dart.cpp
+++ b/src/idl_gen_dart.cpp
@@ -278,6 +278,10 @@ class DartGenerator : public BaseGenerator {
     code += "}\n\n";
 
     GenEnumReader(enum_def, enum_type, code);
+
+    if (enum_def.is_union) {
+      GenUnionReader(enum_def, enum_type, code);
+    }
   }
 
   void GenEnumReader(EnumDef& enum_def, const std::string& enum_type,
@@ -295,6 +299,38 @@ class DartGenerator : public BaseGenerator {
     code += "}\n\n";
   }
 
+  void GenUnionReader(EnumDef& enum_def, const std::string& enum_type,
+                      std::string& code) {
+    code += "class _" + enum_def.name + "Reader extends " + _kFb +
+            ".UnionReader {\n";
+    code += "  _" + enum_def.name + "Reader(" + enum_type +
+            "? type) : super(_get(type));\n\n";
+    code += "  static " + _kFb + ".Reader? _get(" + enum_type + "? type) {\n";
+    code += "    switch (type?.value) {\n";
+    for (auto en_it = enum_def.Vals().begin() + 1;
+         en_it != enum_def.Vals().end(); ++en_it) {
+      const auto& ev = **en_it;
+
+      code += "      case " + enum_def.ToString(ev) + ": return ";
+      if (ev.union_type.base_type == BASE_TYPE_STRING) {
+        code += _kFb + ".StringReader()";
+
+      } else if (ev.union_type.struct_def) {
+        code += NamespaceAliasFromUnionType(enum_def.defined_namespace,
+                                            ev.union_type) +
+                ".reader";
+      } else {
+        assert(0);
+        code += "null";
+      }
+      code += ";\n";
+    }
+    code += "      default: return null;\n";
+    code += "    }\n";
+    code += "  }\n";
+    code += "}\n\n";
+  }
+
   std::string GenType(const Type& type) {
     switch (type.base_type) {
       case BASE_TYPE_BOOL:
@@ -361,26 +397,27 @@ class DartGenerator : public BaseGenerator {
                                 bool parent_is_vector = false, bool lazy = true,
                                 bool constConstruct = true) {
     std::string prefix = (constConstruct ? "const " : "") + _kFb;
-    if (type.base_type == BASE_TYPE_BOOL) {
-      return prefix + ".BoolReader()";
-    } else if (IsVector(type)) {
-      if (!type.VectorType().enum_def) {
-        if (type.VectorType().base_type == BASE_TYPE_CHAR) {
-          return prefix + ".Int8ListReader(" + (lazy ? ")" : "lazy: false)");
-        }
-        if (type.VectorType().base_type == BASE_TYPE_UCHAR) {
-          return prefix + ".Uint8ListReader(" + (lazy ? ")" : "lazy: false)");
-        }
+    if (IsVector(type)) {
+      std::string code = prefix + ".";
+      if (type.VectorType().base_type == BASE_TYPE_UNION) {
+        code = _kFb + ".UnionListReader";
+      } else {
+        code += "ListReader<" +
+                GenDartTypeName(type.VectorType(), current_namespace, def) +
+                ">";
       }
-      return prefix + ".ListReader<" +
-             GenDartTypeName(type.VectorType(), current_namespace, def) + ">(" +
-             GenReaderTypeName(type.VectorType(), current_namespace, def, true,
-                               true, false) +
-             (lazy ? ")" : ", lazy: false)");
+      code += "(" + GenReaderTypeName(type.VectorType(), current_namespace, def,
+                                      true, true, false);
+      if (!lazy) code += ", lazy: false";
+      return code + ")";
+    } else if (type.base_type == BASE_TYPE_UNION) {
+      return "(index) => _" + type.enum_def->name + "Reader(" + def.name +
+             "Type?[index])";
+    } else if (type.base_type == BASE_TYPE_BOOL) {
+      return prefix + ".BoolReader()";
     } else if (IsString(type)) {
       return prefix + ".StringReader()";
-    }
-    if (IsScalar(type.base_type)) {
+    } else if (IsScalar(type.base_type)) {
       if (type.enum_def && parent_is_vector) {
         return GenDartTypeName(type, current_namespace, def) + ".reader";
       }
@@ -393,12 +430,19 @@ class DartGenerator : public BaseGenerator {
   std::string GenDartTypeName(const Type& type, Namespace* current_namespace,
                               const FieldDef& def,
                               std::string struct_type_suffix = "") {
+    if (IsVector(type)) {
+      return "List<" +
+             GenDartTypeName(type.VectorType(), current_namespace, def,
+                             struct_type_suffix) +
+             ">";
+    }
+
     if (type.enum_def) {
       if (type.enum_def->is_union && type.base_type != BASE_TYPE_UNION) {
         return namer_.Type(*type.enum_def) + "TypeId";
       } else if (type.enum_def->is_union) {
         return "dynamic";
-      } else if (type.base_type != BASE_TYPE_VECTOR) {
+      } else {
         const std::string cur_namespace = namer_.Namespace(*current_namespace);
         std::string enum_namespace =
             namer_.Namespace(*type.enum_def->defined_namespace);
@@ -431,11 +475,6 @@ class DartGenerator : public BaseGenerator {
         return MaybeWrapNamespace(
             namer_.Type(*type.struct_def) + struct_type_suffix,
             current_namespace, def);
-      case BASE_TYPE_VECTOR:
-        return "List<" +
-               GenDartTypeName(type.VectorType(), current_namespace, def,
-                               struct_type_suffix) +
-               ">";
       default:
         assert(0);
         return "dynamic";
@@ -617,12 +656,22 @@ class DartGenerator : public BaseGenerator {
       std::string nullableValueAccessOperator = isNullable ? "?" : "";
       if (type.base_type == BASE_TYPE_STRUCT ||
           type.base_type == BASE_TYPE_UNION) {
+        if (type.base_type == BASE_TYPE_UNION) {
+          constructor_args += field_name + " is String ? " + field_name + " : ";
+        }
         constructor_args +=
             field_name + nullableValueAccessOperator + ".unpack()";
       } else if (type.base_type == BASE_TYPE_VECTOR) {
+        const auto& vector_type = type.VectorType();
+
         constructor_args += field_name + nullableValueAccessOperator;
-        if (type.VectorType().base_type == BASE_TYPE_STRUCT) {
-          constructor_args += ".map((e) => e.unpack())";
+        if (vector_type.base_type == BASE_TYPE_STRUCT ||
+            vector_type.base_type == BASE_TYPE_UNION) {
+          constructor_args += ".map((e) => ";
+          if (vector_type.base_type == BASE_TYPE_UNION) {
+            constructor_args += "e is String ? e : ";
+          }
+          constructor_args += "e.unpack())";
         }
         constructor_args += ".toList()";
       } else {
@@ -700,25 +749,13 @@ class DartGenerator : public BaseGenerator {
 
       GenDocComment(field.doc_comment, "  ", code);
 
-      code += "  " + type_name + " get " + field_name;
+      code += "  " + type_name + " get " + field_name + " => ";
       if (field.value.type.base_type == BASE_TYPE_UNION) {
-        code += " {\n";
-        code += "    switch (" + field_name + "Type?.value) {\n";
         const auto& enum_def = *field.value.type.enum_def;
-        for (auto en_it = enum_def.Vals().begin() + 1;
-             en_it != enum_def.Vals().end(); ++en_it) {
-          const auto& ev = **en_it;
-          const auto enum_name = NamespaceAliasFromUnionType(
-              enum_def.defined_namespace, ev.union_type);
-          code += "      case " + enum_def.ToString(ev) + ": return " +
-                  enum_name + ".reader.vTableGetNullable(_bc, _bcOffset, " +
-                  NumToString(field.value.offset) + ");\n";
-        }
-        code += "      default: return null;\n";
-        code += "    }\n";
-        code += "  }\n";
+        code += "_" + enum_def.name + "Reader(" + field_name +
+                "Type).vTableGetNullable(_bc, _bcOffset, " +
+                NumToString(field.value.offset) + ");\n";
       } else {
-        code += " => ";
         if (field.value.type.enum_def &&
             field.value.type.base_type != BASE_TYPE_VECTOR) {
           code += GenDartTypeName(field.value.type,
@@ -1053,6 +1090,13 @@ class DartGenerator : public BaseGenerator {
                       "(fbBuilder)).toList());\n";
             }
             break;
+          case BASE_TYPE_UNION:
+            code += "(" + field_name +
+                    "!.map<int>((u) => u is String ? fbBuilder.writeString(u) "
+                    ": u." +
+                    (pack ? "pack" : "getOrCreateOffset") +
+                    "(fbBuilder)).toList());\n";
+            break;
           default:
             code +=
                 GenType(field.value.type.VectorType()) + "(" + field_name + "!";
@@ -1065,8 +1109,13 @@ class DartGenerator : public BaseGenerator {
         code += " = " + field_name + " == null ? null\n";
         code += "        : fbBuilder.writeString(" + field_name + "!);\n";
       } else {
-        code += " = " + field_name + "?." +
-                (pack ? "pack" : "getOrCreateOffset") + "(fbBuilder);\n";
+        code += " = ";
+        if (field.value.type.base_type == BASE_TYPE_UNION) {
+          code += field_name + " is String ? fbBuilder.writeString(" +
+                  field_name + ") : ";
+        }
+        code += field_name + "?." + (pack ? "pack" : "getOrCreateOffset") +
+                "(fbBuilder);\n";
       }
     }
 
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp
index 7af234aa8b7..6f5f2ce814a 100644
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -2751,7 +2751,8 @@ bool Parser::SupportsAdvancedUnionFeatures() const {
           ~(IDLOptions::kCpp | IDLOptions::kTs | IDLOptions::kPhp |
             IDLOptions::kJava | IDLOptions::kCSharp | IDLOptions::kKotlin |
             IDLOptions::kBinary | IDLOptions::kSwift | IDLOptions::kNim |
-            IDLOptions::kJson | IDLOptions::kKotlinKmp)) == 0;
+            IDLOptions::kJson | IDLOptions::kKotlinKmp | IDLOptions::kDart)) ==
+         0;
 }
 
 bool Parser::SupportsAdvancedArrayFeatures() const {
diff --git a/tests/monster_test_my_game.example_generated.dart b/tests/monster_test_my_game.example_generated.dart
index 81d6d9caa3b..4059902a5e8 100644
--- a/tests/monster_test_my_game.example_generated.dart
+++ b/tests/monster_test_my_game.example_generated.dart
@@ -23,11 +23,16 @@ enum Color {
 
   factory Color.fromValue(int value) {
     switch (value) {
-      case 1: return Color.Red;
-      case 2: return Color.Green;
-      case 8: return Color.Blue;
-      case 0: return Color._default;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case 1:
+        return Color.Red;
+      case 2:
+        return Color.Green;
+      case 8:
+        return Color.Blue;
+      case 0:
+        return Color._default;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -59,11 +64,16 @@ enum Race {
 
   factory Race.fromValue(int value) {
     switch (value) {
-      case -1: return Race.None;
-      case 0: return Race.Human;
-      case 1: return Race.Dwarf;
-      case 2: return Race.Elf;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case -1:
+        return Race.None;
+      case 0:
+        return Race.Human;
+      case 1:
+        return Race.Dwarf;
+      case 2:
+        return Race.Elf;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -97,11 +107,16 @@ enum LongEnum {
 
   factory LongEnum.fromValue(int value) {
     switch (value) {
-      case 2: return LongEnum.LongOne;
-      case 4: return LongEnum.LongTwo;
-      case 1099511627776: return LongEnum.LongBig;
-      case 0: return LongEnum._default;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case 2:
+        return LongEnum.LongOne;
+      case 4:
+        return LongEnum.LongTwo;
+      case 1099511627776:
+        return LongEnum.LongBig;
+      case 0:
+        return LongEnum._default;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -133,11 +148,16 @@ enum AnyTypeId {
 
   factory AnyTypeId.fromValue(int value) {
     switch (value) {
-      case 0: return AnyTypeId.NONE;
-      case 1: return AnyTypeId.Monster;
-      case 2: return AnyTypeId.TestSimpleTableWithEnum;
-      case 3: return AnyTypeId.MyGame_Example2_Monster;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case 0:
+        return AnyTypeId.NONE;
+      case 1:
+        return AnyTypeId.Monster;
+      case 2:
+        return AnyTypeId.TestSimpleTableWithEnum;
+      case 3:
+        return AnyTypeId.MyGame_Example2_Monster;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -160,6 +180,23 @@ class _AnyTypeIdReader extends fb.Reader<AnyTypeId> {
       AnyTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
+class _AnyReader extends fb.UnionReader {
+  _AnyReader(AnyTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(AnyTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return TestSimpleTableWithEnum.reader;
+      case 3:
+        return my_game_example2.Monster.reader;
+      default:
+        return null;
+    }
+  }
+}
+
 enum AnyUniqueAliasesTypeId {
   NONE(0),
   M(1),
@@ -171,11 +208,16 @@ enum AnyUniqueAliasesTypeId {
 
   factory AnyUniqueAliasesTypeId.fromValue(int value) {
     switch (value) {
-      case 0: return AnyUniqueAliasesTypeId.NONE;
-      case 1: return AnyUniqueAliasesTypeId.M;
-      case 2: return AnyUniqueAliasesTypeId.TS;
-      case 3: return AnyUniqueAliasesTypeId.M2;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case 0:
+        return AnyUniqueAliasesTypeId.NONE;
+      case 1:
+        return AnyUniqueAliasesTypeId.M;
+      case 2:
+        return AnyUniqueAliasesTypeId.TS;
+      case 3:
+        return AnyUniqueAliasesTypeId.M2;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -184,7 +226,8 @@ enum AnyUniqueAliasesTypeId {
 
   static const int minValue = 0;
   static const int maxValue = 3;
-  static const fb.Reader<AnyUniqueAliasesTypeId> reader = _AnyUniqueAliasesTypeIdReader();
+  static const fb.Reader<AnyUniqueAliasesTypeId> reader =
+      _AnyUniqueAliasesTypeIdReader();
 }
 
 class _AnyUniqueAliasesTypeIdReader extends fb.Reader<AnyUniqueAliasesTypeId> {
@@ -198,6 +241,23 @@ class _AnyUniqueAliasesTypeIdReader extends fb.Reader<AnyUniqueAliasesTypeId> {
       AnyUniqueAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
 }
 
+class _AnyUniqueAliasesReader extends fb.UnionReader {
+  _AnyUniqueAliasesReader(AnyUniqueAliasesTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(AnyUniqueAliasesTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return TestSimpleTableWithEnum.reader;
+      case 3:
+        return my_game_example2.Monster.reader;
+      default:
+        return null;
+    }
+  }
+}
+
 enum AnyAmbiguousAliasesTypeId {
   NONE(0),
   M1(1),
@@ -209,11 +269,16 @@ enum AnyAmbiguousAliasesTypeId {
 
   factory AnyAmbiguousAliasesTypeId.fromValue(int value) {
     switch (value) {
-      case 0: return AnyAmbiguousAliasesTypeId.NONE;
-      case 1: return AnyAmbiguousAliasesTypeId.M1;
-      case 2: return AnyAmbiguousAliasesTypeId.M2;
-      case 3: return AnyAmbiguousAliasesTypeId.M3;
-      default: throw StateError('Invalid value $value for bit flag enum');
+      case 0:
+        return AnyAmbiguousAliasesTypeId.NONE;
+      case 1:
+        return AnyAmbiguousAliasesTypeId.M1;
+      case 2:
+        return AnyAmbiguousAliasesTypeId.M2;
+      case 3:
+        return AnyAmbiguousAliasesTypeId.M3;
+      default:
+        throw StateError('Invalid value $value for bit flag enum');
     }
   }
 
@@ -222,10 +287,12 @@ enum AnyAmbiguousAliasesTypeId {
 
   static const int minValue = 0;
   static const int maxValue = 3;
-  static const fb.Reader<AnyAmbiguousAliasesTypeId> reader = _AnyAmbiguousAliasesTypeIdReader();
+  static const fb.Reader<AnyAmbiguousAliasesTypeId> reader =
+      _AnyAmbiguousAliasesTypeIdReader();
 }
 
-class _AnyAmbiguousAliasesTypeIdReader extends fb.Reader<AnyAmbiguousAliasesTypeId> {
+class _AnyAmbiguousAliasesTypeIdReader
+    extends fb.Reader<AnyAmbiguousAliasesTypeId> {
   const _AnyAmbiguousAliasesTypeIdReader();
 
   @override
@@ -233,7 +300,27 @@ class _AnyAmbiguousAliasesTypeIdReader extends fb.Reader<AnyAmbiguousAliasesType
 
   @override
   AnyAmbiguousAliasesTypeId read(fb.BufferContext bc, int offset) =>
-      AnyAmbiguousAliasesTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+      AnyAmbiguousAliasesTypeId.fromValue(
+        const fb.Uint8Reader().read(bc, offset),
+      );
+}
+
+class _AnyAmbiguousAliasesReader extends fb.UnionReader {
+  _AnyAmbiguousAliasesReader(AnyAmbiguousAliasesTypeId? type)
+    : super(_get(type));
+
+  static fb.Reader? _get(AnyAmbiguousAliasesTypeId? type) {
+    switch (type?.value) {
+      case 1:
+        return Monster.reader;
+      case 2:
+        return Monster.reader;
+      case 3:
+        return Monster.reader;
+      default:
+        return null;
+    }
+  }
 }
 
 class Test {
@@ -252,9 +339,7 @@ class Test {
     return 'Test{a: ${a}, b: ${b}}';
   }
 
-  TestT unpack() => TestT(
-      a: a,
-      b: b);
+  TestT unpack() => TestT(a: a, b: b);
 
   static int pack(fb.Builder fbBuilder, TestT? object) {
     if (object == null) return 0;
@@ -266,9 +351,7 @@ class TestT implements fb.Packable {
   int a;
   int b;
 
-  TestT({
-      required this.a,
-      required this.b});
+  TestT({required this.a, required this.b});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -291,8 +374,7 @@ class _TestReader extends fb.StructReader<Test> {
   int get size => 4;
 
   @override
-  Test createObject(fb.BufferContext bc, int offset) => 
-    Test._(bc, offset);
+  Test createObject(fb.BufferContext bc, int offset) => Test._(bc, offset);
 }
 
 class TestBuilder {
@@ -306,19 +388,13 @@ class TestBuilder {
     fbBuilder.putInt16(a);
     return fbBuilder.offset;
   }
-
 }
 
 class TestObjectBuilder extends fb.ObjectBuilder {
   final int _a;
   final int _b;
 
-  TestObjectBuilder({
-    required int a,
-    required int b,
-  })
-      : _a = a,
-        _b = b;
+  TestObjectBuilder({required int a, required int b}) : _a = a, _b = b;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -337,6 +413,7 @@ class TestObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class TestSimpleTableWithEnum {
   TestSimpleTableWithEnum._(this._bc, this._bcOffset);
   factory TestSimpleTableWithEnum(List<int> bytes) {
@@ -344,20 +421,21 @@ class TestSimpleTableWithEnum {
     return reader.read(rootRef, 0);
   }
 
-  static const fb.Reader<TestSimpleTableWithEnum> reader = _TestSimpleTableWithEnumReader();
+  static const fb.Reader<TestSimpleTableWithEnum> reader =
+      _TestSimpleTableWithEnumReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
 
-  Color get color => Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 4, 2));
+  Color get color =>
+      Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 4, 2));
 
   @override
   String toString() {
     return 'TestSimpleTableWithEnum{color: ${color}}';
   }
 
-  TestSimpleTableWithEnumT unpack() => TestSimpleTableWithEnumT(
-      color: color);
+  TestSimpleTableWithEnumT unpack() => TestSimpleTableWithEnumT(color: color);
 
   static int pack(fb.Builder fbBuilder, TestSimpleTableWithEnumT? object) {
     if (object == null) return 0;
@@ -368,8 +446,7 @@ class TestSimpleTableWithEnum {
 class TestSimpleTableWithEnumT implements fb.Packable {
   Color color;
 
-  TestSimpleTableWithEnumT({
-      this.color = Color.Green});
+  TestSimpleTableWithEnumT({this.color = Color.Green});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -384,12 +461,13 @@ class TestSimpleTableWithEnumT implements fb.Packable {
   }
 }
 
-class _TestSimpleTableWithEnumReader extends fb.TableReader<TestSimpleTableWithEnum> {
+class _TestSimpleTableWithEnumReader
+    extends fb.TableReader<TestSimpleTableWithEnum> {
   const _TestSimpleTableWithEnumReader();
 
   @override
-  TestSimpleTableWithEnum createObject(fb.BufferContext bc, int offset) => 
-    TestSimpleTableWithEnum._(bc, offset);
+  TestSimpleTableWithEnum createObject(fb.BufferContext bc, int offset) =>
+      TestSimpleTableWithEnum._(bc, offset);
 }
 
 class TestSimpleTableWithEnumBuilder {
@@ -414,10 +492,7 @@ class TestSimpleTableWithEnumBuilder {
 class TestSimpleTableWithEnumObjectBuilder extends fb.ObjectBuilder {
   final Color? _color;
 
-  TestSimpleTableWithEnumObjectBuilder({
-    Color? color,
-  })
-      : _color = color;
+  TestSimpleTableWithEnumObjectBuilder({Color? color}) : _color = color;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -435,6 +510,7 @@ class TestSimpleTableWithEnumObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class Vec3 {
   Vec3._(this._bc, this._bcOffset);
 
@@ -447,7 +523,8 @@ class Vec3 {
   double get y => const fb.Float32Reader().read(_bc, _bcOffset + 4);
   double get z => const fb.Float32Reader().read(_bc, _bcOffset + 8);
   double get test1 => const fb.Float64Reader().read(_bc, _bcOffset + 16);
-  Color get test2 => Color.fromValue(const fb.Uint8Reader().read(_bc, _bcOffset + 24));
+  Color get test2 =>
+      Color.fromValue(const fb.Uint8Reader().read(_bc, _bcOffset + 24));
   Test get test3 => Test.reader.read(_bc, _bcOffset + 26);
 
   @override
@@ -456,12 +533,13 @@ class Vec3 {
   }
 
   Vec3T unpack() => Vec3T(
-      x: x,
-      y: y,
-      z: z,
-      test1: test1,
-      test2: test2,
-      test3: test3.unpack());
+    x: x,
+    y: y,
+    z: z,
+    test1: test1,
+    test2: test2,
+    test3: test3.unpack(),
+  );
 
   static int pack(fb.Builder fbBuilder, Vec3T? object) {
     if (object == null) return 0;
@@ -478,12 +556,13 @@ class Vec3T implements fb.Packable {
   TestT test3;
 
   Vec3T({
-      required this.x,
-      required this.y,
-      required this.z,
-      required this.test1,
-      required this.test2,
-      required this.test3});
+    required this.x,
+    required this.y,
+    required this.z,
+    required this.test1,
+    required this.test2,
+    required this.test3,
+  });
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -512,8 +591,7 @@ class _Vec3Reader extends fb.StructReader<Vec3> {
   int get size => 32;
 
   @override
-  Vec3 createObject(fb.BufferContext bc, int offset) => 
-    Vec3._(bc, offset);
+  Vec3 createObject(fb.BufferContext bc, int offset) => Vec3._(bc, offset);
 }
 
 class Vec3Builder {
@@ -521,7 +599,14 @@ class Vec3Builder {
 
   final fb.Builder fbBuilder;
 
-  int finish(double x, double y, double z, double test1, Color test2, fb.StructBuilder test3) {
+  int finish(
+    double x,
+    double y,
+    double z,
+    double test1,
+    Color test2,
+    fb.StructBuilder test3,
+  ) {
     fbBuilder.pad(2);
     test3();
     fbBuilder.pad(1);
@@ -533,7 +618,6 @@ class Vec3Builder {
     fbBuilder.putFloat32(x);
     return fbBuilder.offset;
   }
-
 }
 
 class Vec3ObjectBuilder extends fb.ObjectBuilder {
@@ -551,13 +635,12 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
     required double test1,
     required Color test2,
     required TestObjectBuilder test3,
-  })
-      : _x = x,
-        _y = y,
-        _z = z,
-        _test1 = test1,
-        _test2 = test2,
-        _test3 = test3;
+  }) : _x = x,
+       _y = y,
+       _z = z,
+       _test1 = test1,
+       _test2 = test2,
+       _test3 = test3;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -582,6 +665,7 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class Ability {
   Ability._(this._bc, this._bcOffset);
 
@@ -598,9 +682,7 @@ class Ability {
     return 'Ability{id: ${id}, distance: ${distance}}';
   }
 
-  AbilityT unpack() => AbilityT(
-      id: id,
-      distance: distance);
+  AbilityT unpack() => AbilityT(id: id, distance: distance);
 
   static int pack(fb.Builder fbBuilder, AbilityT? object) {
     if (object == null) return 0;
@@ -612,9 +694,7 @@ class AbilityT implements fb.Packable {
   int id;
   int distance;
 
-  AbilityT({
-      required this.id,
-      required this.distance});
+  AbilityT({required this.id, required this.distance});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -636,8 +716,8 @@ class _AbilityReader extends fb.StructReader<Ability> {
   int get size => 8;
 
   @override
-  Ability createObject(fb.BufferContext bc, int offset) => 
-    Ability._(bc, offset);
+  Ability createObject(fb.BufferContext bc, int offset) =>
+      Ability._(bc, offset);
 }
 
 class AbilityBuilder {
@@ -650,19 +730,15 @@ class AbilityBuilder {
     fbBuilder.putUint32(id);
     return fbBuilder.offset;
   }
-
 }
 
 class AbilityObjectBuilder extends fb.ObjectBuilder {
   final int _id;
   final int _distance;
 
-  AbilityObjectBuilder({
-    required int id,
-    required int distance,
-  })
-      : _id = id,
-        _distance = distance;
+  AbilityObjectBuilder({required int id, required int distance})
+    : _id = id,
+      _distance = distance;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -680,6 +756,7 @@ class AbilityObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class StructOfStructs {
   StructOfStructs._(this._bc, this._bcOffset);
 
@@ -697,10 +774,8 @@ class StructOfStructs {
     return 'StructOfStructs{a: ${a}, b: ${b}, c: ${c}}';
   }
 
-  StructOfStructsT unpack() => StructOfStructsT(
-      a: a.unpack(),
-      b: b.unpack(),
-      c: c.unpack());
+  StructOfStructsT unpack() =>
+      StructOfStructsT(a: a.unpack(), b: b.unpack(), c: c.unpack());
 
   static int pack(fb.Builder fbBuilder, StructOfStructsT? object) {
     if (object == null) return 0;
@@ -713,10 +788,7 @@ class StructOfStructsT implements fb.Packable {
   TestT b;
   AbilityT c;
 
-  StructOfStructsT({
-      required this.a,
-      required this.b,
-      required this.c});
+  StructOfStructsT({required this.a, required this.b, required this.c});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -739,8 +811,8 @@ class _StructOfStructsReader extends fb.StructReader<StructOfStructs> {
   int get size => 20;
 
   @override
-  StructOfStructs createObject(fb.BufferContext bc, int offset) => 
-    StructOfStructs._(bc, offset);
+  StructOfStructs createObject(fb.BufferContext bc, int offset) =>
+      StructOfStructs._(bc, offset);
 }
 
 class StructOfStructsBuilder {
@@ -754,7 +826,6 @@ class StructOfStructsBuilder {
     a();
     return fbBuilder.offset;
   }
-
 }
 
 class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
@@ -766,10 +837,9 @@ class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
     required AbilityObjectBuilder a,
     required TestObjectBuilder b,
     required AbilityObjectBuilder c,
-  })
-      : _a = a,
-        _b = b,
-        _c = c;
+  }) : _a = a,
+       _b = b,
+       _c = c;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -788,10 +858,12 @@ class StructOfStructsObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class StructOfStructsOfStructs {
   StructOfStructsOfStructs._(this._bc, this._bcOffset);
 
-  static const fb.Reader<StructOfStructsOfStructs> reader = _StructOfStructsOfStructsReader();
+  static const fb.Reader<StructOfStructsOfStructs> reader =
+      _StructOfStructsOfStructsReader();
 
   final fb.BufferContext _bc;
   final int _bcOffset;
@@ -803,8 +875,8 @@ class StructOfStructsOfStructs {
     return 'StructOfStructsOfStructs{a: ${a}}';
   }
 
-  StructOfStructsOfStructsT unpack() => StructOfStructsOfStructsT(
-      a: a.unpack());
+  StructOfStructsOfStructsT unpack() =>
+      StructOfStructsOfStructsT(a: a.unpack());
 
   static int pack(fb.Builder fbBuilder, StructOfStructsOfStructsT? object) {
     if (object == null) return 0;
@@ -815,8 +887,7 @@ class StructOfStructsOfStructs {
 class StructOfStructsOfStructsT implements fb.Packable {
   StructOfStructsT a;
 
-  StructOfStructsOfStructsT({
-      required this.a});
+  StructOfStructsOfStructsT({required this.a});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -830,15 +901,16 @@ class StructOfStructsOfStructsT implements fb.Packable {
   }
 }
 
-class _StructOfStructsOfStructsReader extends fb.StructReader<StructOfStructsOfStructs> {
+class _StructOfStructsOfStructsReader
+    extends fb.StructReader<StructOfStructsOfStructs> {
   const _StructOfStructsOfStructsReader();
 
   @override
   int get size => 20;
 
   @override
-  StructOfStructsOfStructs createObject(fb.BufferContext bc, int offset) => 
-    StructOfStructsOfStructs._(bc, offset);
+  StructOfStructsOfStructs createObject(fb.BufferContext bc, int offset) =>
+      StructOfStructsOfStructs._(bc, offset);
 }
 
 class StructOfStructsOfStructsBuilder {
@@ -850,7 +922,6 @@ class StructOfStructsOfStructsBuilder {
     a();
     return fbBuilder.offset;
   }
-
 }
 
 class StructOfStructsOfStructsObjectBuilder extends fb.ObjectBuilder {
@@ -858,8 +929,7 @@ class StructOfStructsOfStructsObjectBuilder extends fb.ObjectBuilder {
 
   StructOfStructsOfStructsObjectBuilder({
     required StructOfStructsObjectBuilder a,
-  })
-      : _a = a;
+  }) : _a = a;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -876,6 +946,7 @@ class StructOfStructsOfStructsObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class Stat {
   Stat._(this._bc, this._bcOffset);
   factory Stat(List<int> bytes) {
@@ -888,7 +959,8 @@ class Stat {
   final fb.BufferContext _bc;
   final int _bcOffset;
 
-  String? get id => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
+  String? get id =>
+      const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
   int get val => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 6, 0);
   int get count => const fb.Uint16Reader().vTableGet(_bc, _bcOffset, 8, 0);
 
@@ -897,10 +969,7 @@ class Stat {
     return 'Stat{id: ${id}, val: ${val}, count: ${count}}';
   }
 
-  StatT unpack() => StatT(
-      id: id,
-      val: val,
-      count: count);
+  StatT unpack() => StatT(id: id, val: val, count: count);
 
   static int pack(fb.Builder fbBuilder, StatT? object) {
     if (object == null) return 0;
@@ -913,15 +982,11 @@ class StatT implements fb.Packable {
   int val;
   int count;
 
-  StatT({
-      this.id,
-      this.val = 0,
-      this.count = 0});
+  StatT({this.id, this.val = 0, this.count = 0});
 
   @override
   int pack(fb.Builder fbBuilder) {
-    final int? idOffset = id == null ? null
-        : fbBuilder.writeString(id!);
+    final int? idOffset = id == null ? null : fbBuilder.writeString(id!);
     fbBuilder.startTable(3);
     fbBuilder.addOffset(0, idOffset);
     fbBuilder.addInt64(1, val);
@@ -939,8 +1004,7 @@ class _StatReader extends fb.TableReader<Stat> {
   const _StatReader();
 
   @override
-  Stat createObject(fb.BufferContext bc, int offset) => 
-    Stat._(bc, offset);
+  Stat createObject(fb.BufferContext bc, int offset) => Stat._(bc, offset);
 }
 
 class StatBuilder {
@@ -956,10 +1020,12 @@ class StatBuilder {
     fbBuilder.addOffset(0, offset);
     return fbBuilder.offset;
   }
+
   int addVal(int? val) {
     fbBuilder.addInt64(1, val);
     return fbBuilder.offset;
   }
+
   int addCount(int? count) {
     fbBuilder.addUint16(2, count);
     return fbBuilder.offset;
@@ -975,20 +1041,15 @@ class StatObjectBuilder extends fb.ObjectBuilder {
   final int? _val;
   final int? _count;
 
-  StatObjectBuilder({
-    String? id,
-    int? val,
-    int? count,
-  })
-      : _id = id,
-        _val = val,
-        _count = count;
+  StatObjectBuilder({String? id, int? val, int? count})
+    : _id = id,
+      _val = val,
+      _count = count;
 
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
-    final int? idOffset = _id == null ? null
-        : fbBuilder.writeString(_id!);
+    final int? idOffset = _id == null ? null : fbBuilder.writeString(_id!);
     fbBuilder.startTable(3);
     fbBuilder.addOffset(0, idOffset);
     fbBuilder.addInt64(1, _val);
@@ -1004,6 +1065,7 @@ class StatObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class Referrable {
   Referrable._(this._bc, this._bcOffset);
   factory Referrable(List<int> bytes) {
@@ -1023,8 +1085,7 @@ class Referrable {
     return 'Referrable{id: ${id}}';
   }
 
-  ReferrableT unpack() => ReferrableT(
-      id: id);
+  ReferrableT unpack() => ReferrableT(id: id);
 
   static int pack(fb.Builder fbBuilder, ReferrableT? object) {
     if (object == null) return 0;
@@ -1035,8 +1096,7 @@ class Referrable {
 class ReferrableT implements fb.Packable {
   int id;
 
-  ReferrableT({
-      this.id = 0});
+  ReferrableT({this.id = 0});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -1055,8 +1115,8 @@ class _ReferrableReader extends fb.TableReader<Referrable> {
   const _ReferrableReader();
 
   @override
-  Referrable createObject(fb.BufferContext bc, int offset) => 
-    Referrable._(bc, offset);
+  Referrable createObject(fb.BufferContext bc, int offset) =>
+      Referrable._(bc, offset);
 }
 
 class ReferrableBuilder {
@@ -1081,10 +1141,7 @@ class ReferrableBuilder {
 class ReferrableObjectBuilder extends fb.ObjectBuilder {
   final int? _id;
 
-  ReferrableObjectBuilder({
-    int? id,
-  })
-      : _id = id;
+  ReferrableObjectBuilder({int? id}) : _id = id;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -1102,6 +1159,7 @@ class ReferrableObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 ///  an example documentation comment: "monster object"
 class Monster {
   Monster._(this._bc, this._bcOffset);
@@ -1118,87 +1176,150 @@ class Monster {
   Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);
   int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);
   int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);
-  String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
-  List<int>? get inventory => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
-  Color get color => Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));
-  AnyTypeId? get testType => AnyTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18));
-  dynamic get test {
-    switch (testType?.value) {
-      case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);
-      case 2: return TestSimpleTableWithEnum.reader.vTableGetNullable(_bc, _bcOffset, 20);
-      case 3: return my_game_example2.Monster.reader.vTableGetNullable(_bc, _bcOffset, 20);
-      default: return null;
-    }
-  }
-  List<Test>? get test4 => const fb.ListReader<Test>(Test.reader).vTableGetNullable(_bc, _bcOffset, 22);
-  List<String>? get testarrayofstring => const fb.ListReader<String>(fb.StringReader()).vTableGetNullable(_bc, _bcOffset, 24);
+  String? get name =>
+      const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
+  List<int>? get inventory =>
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 14);
+  Color get color =>
+      Color.fromValue(const fb.Uint8Reader().vTableGet(_bc, _bcOffset, 16, 8));
+  AnyTypeId? get testType => AnyTypeId._createOrNull(
+    const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 18),
+  );
+  dynamic get test => _AnyReader(testType).vTableGetNullable(_bc, _bcOffset, 20);
+  List<Test>? get test4 => const fb.ListReader<Test>(
+    Test.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 22);
+  List<String>? get testarrayofstring => const fb.ListReader<String>(
+    fb.StringReader(),
+  ).vTableGetNullable(_bc, _bcOffset, 24);
+
   ///  an example documentation comment: this will end up in the generated code
   ///  multiline too
-  List<Monster>? get testarrayoftables => const fb.ListReader<Monster>(Monster.reader).vTableGetNullable(_bc, _bcOffset, 26);
+  List<Monster>? get testarrayoftables => const fb.ListReader<Monster>(
+    Monster.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 26);
   Monster? get enemy => Monster.reader.vTableGetNullable(_bc, _bcOffset, 28);
-  List<int>? get testnestedflatbuffer => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 30);
+  List<int>? get testnestedflatbuffer =>
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 30);
   Stat? get testempty => Stat.reader.vTableGetNullable(_bc, _bcOffset, 32);
-  bool get testbool => const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);
-  int get testhashs32Fnv1 => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 36, 0);
-  int get testhashu32Fnv1 => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 38, 0);
-  int get testhashs64Fnv1 => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 40, 0);
-  int get testhashu64Fnv1 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 42, 0);
-  int get testhashs32Fnv1a => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 44, 0);
-  int get testhashu32Fnv1a => const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 46, 0);
-  int get testhashs64Fnv1a => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 48, 0);
-  int get testhashu64Fnv1a => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);
-  List<bool>? get testarrayofbools => const fb.ListReader<bool>(fb.BoolReader()).vTableGetNullable(_bc, _bcOffset, 52);
-  double get testf => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);
-  double get testf2 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 56, 3.0);
-  double get testf3 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);
-  List<String>? get testarrayofstring2 => const fb.ListReader<String>(fb.StringReader()).vTableGetNullable(_bc, _bcOffset, 60);
-  List<Ability>? get testarrayofsortedstruct => const fb.ListReader<Ability>(Ability.reader).vTableGetNullable(_bc, _bcOffset, 62);
-  List<int>? get flex => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 64);
-  List<Test>? get test5 => const fb.ListReader<Test>(Test.reader).vTableGetNullable(_bc, _bcOffset, 66);
-  List<int>? get vectorOfLongs => const fb.ListReader<int>(fb.Int64Reader()).vTableGetNullable(_bc, _bcOffset, 68);
-  List<double>? get vectorOfDoubles => const fb.ListReader<double>(fb.Float64Reader()).vTableGetNullable(_bc, _bcOffset, 70);
-  my_game.InParentNamespace? get parentNamespaceTest => my_game.InParentNamespace.reader.vTableGetNullable(_bc, _bcOffset, 72);
-  List<Referrable>? get vectorOfReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGetNullable(_bc, _bcOffset, 74);
-  int get singleWeakReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);
-  List<int>? get vectorOfWeakReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 78);
-  List<Referrable>? get vectorOfStrongReferrables => const fb.ListReader<Referrable>(Referrable.reader).vTableGetNullable(_bc, _bcOffset, 80);
-  int get coOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);
-  List<int>? get vectorOfCoOwningReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 84);
-  int get nonOwningReference => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);
-  List<int>? get vectorOfNonOwningReferences => const fb.ListReader<int>(fb.Uint64Reader()).vTableGetNullable(_bc, _bcOffset, 88);
-  AnyUniqueAliasesTypeId? get anyUniqueType => AnyUniqueAliasesTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 90));
-  dynamic get anyUnique {
-    switch (anyUniqueType?.value) {
-      case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);
-      case 2: return TestSimpleTableWithEnum.reader.vTableGetNullable(_bc, _bcOffset, 92);
-      case 3: return my_game_example2.Monster.reader.vTableGetNullable(_bc, _bcOffset, 92);
-      default: return null;
-    }
-  }
-  AnyAmbiguousAliasesTypeId? get anyAmbiguousType => AnyAmbiguousAliasesTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 94));
-  dynamic get anyAmbiguous {
-    switch (anyAmbiguousType?.value) {
-      case 1: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      case 2: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      case 3: return Monster.reader.vTableGetNullable(_bc, _bcOffset, 96);
-      default: return null;
-    }
-  }
-  List<Color>? get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGetNullable(_bc, _bcOffset, 98);
-  Race get signedEnum => Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
-  List<int>? get testrequirednestedflatbuffer => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 102);
-  List<Stat>? get scalarKeySortedTables => const fb.ListReader<Stat>(Stat.reader).vTableGetNullable(_bc, _bcOffset, 104);
+  bool get testbool =>
+      const fb.BoolReader().vTableGet(_bc, _bcOffset, 34, false);
+  int get testhashs32Fnv1 =>
+      const fb.Int32Reader().vTableGet(_bc, _bcOffset, 36, 0);
+  int get testhashu32Fnv1 =>
+      const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 38, 0);
+  int get testhashs64Fnv1 =>
+      const fb.Int64Reader().vTableGet(_bc, _bcOffset, 40, 0);
+  int get testhashu64Fnv1 =>
+      const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 42, 0);
+  int get testhashs32Fnv1a =>
+      const fb.Int32Reader().vTableGet(_bc, _bcOffset, 44, 0);
+  int get testhashu32Fnv1a =>
+      const fb.Uint32Reader().vTableGet(_bc, _bcOffset, 46, 0);
+  int get testhashs64Fnv1a =>
+      const fb.Int64Reader().vTableGet(_bc, _bcOffset, 48, 0);
+  int get testhashu64Fnv1a =>
+      const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 50, 0);
+  List<bool>? get testarrayofbools => const fb.ListReader<bool>(
+    fb.BoolReader(),
+  ).vTableGetNullable(_bc, _bcOffset, 52);
+  double get testf =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 54, 3.14159);
+  double get testf2 =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 56, 3.0);
+  double get testf3 =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 58, 0.0);
+  List<String>? get testarrayofstring2 => const fb.ListReader<String>(
+    fb.StringReader(),
+  ).vTableGetNullable(_bc, _bcOffset, 60);
+  List<Ability>? get testarrayofsortedstruct => const fb.ListReader<Ability>(
+    Ability.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 62);
+  List<int>? get flex =>
+      const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 64);
+  List<Test>? get test5 => const fb.ListReader<Test>(
+    Test.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 66);
+  List<int>? get vectorOfLongs => const fb.ListReader<int>(
+    fb.Int64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 68);
+  List<double>? get vectorOfDoubles => const fb.ListReader<double>(
+    fb.Float64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 70);
+  my_game.InParentNamespace? get parentNamespaceTest =>
+      my_game.InParentNamespace.reader.vTableGetNullable(_bc, _bcOffset, 72);
+  List<Referrable>? get vectorOfReferrables => const fb.ListReader<Referrable>(
+    Referrable.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 74);
+  int get singleWeakReference =>
+      const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 76, 0);
+  List<int>? get vectorOfWeakReferences => const fb.ListReader<int>(
+    fb.Uint64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 78);
+  List<Referrable>? get vectorOfStrongReferrables =>
+      const fb.ListReader<Referrable>(
+        Referrable.reader,
+      ).vTableGetNullable(_bc, _bcOffset, 80);
+  int get coOwningReference =>
+      const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 82, 0);
+  List<int>? get vectorOfCoOwningReferences => const fb.ListReader<int>(
+    fb.Uint64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 84);
+  int get nonOwningReference =>
+      const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 86, 0);
+  List<int>? get vectorOfNonOwningReferences => const fb.ListReader<int>(
+    fb.Uint64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 88);
+  AnyUniqueAliasesTypeId? get anyUniqueType =>
+      AnyUniqueAliasesTypeId._createOrNull(
+        const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 90),
+      );
+  dynamic get anyUnique => _AnyUniqueAliasesReader(anyUniqueType).vTableGetNullable(_bc, _bcOffset, 92);
+  AnyAmbiguousAliasesTypeId? get anyAmbiguousType =>
+      AnyAmbiguousAliasesTypeId._createOrNull(
+        const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 94),
+      );
+  dynamic get anyAmbiguous => _AnyAmbiguousAliasesReader(anyAmbiguousType).vTableGetNullable(_bc, _bcOffset, 96);
+  List<Color>? get vectorOfEnums => const fb.ListReader<Color>(
+    Color.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 98);
+  Race get signedEnum =>
+      Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
+  List<int>? get testrequirednestedflatbuffer => const fb.ListReader<int>(fb.Uint8Reader()).vTableGetNullable(_bc, _bcOffset, 102);
+  List<Stat>? get scalarKeySortedTables => const fb.ListReader<Stat>(
+    Stat.reader,
+  ).vTableGetNullable(_bc, _bcOffset, 104);
   Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
-  LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0));
-  LongEnum get longEnumNormalDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2));
-  double get nanDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
-  double get infDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);
-  double get positiveInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);
-  double get infinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);
-  double get positiveInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
-  double get negativeInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 122, double.negativeInfinity);
-  double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 124, double.negativeInfinity);
-  double get doubleInfDefault => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
+  LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(
+    const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0),
+  );
+  LongEnum get longEnumNormalDefault => LongEnum.fromValue(
+    const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2),
+  );
+  double get nanDefault =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
+  double get infDefault =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);
+  double get positiveInfDefault =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);
+  double get infinityDefault =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);
+  double get positiveInfinityDefault =>
+      const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
+  double get negativeInfDefault => const fb.Float32Reader().vTableGet(
+    _bc,
+    _bcOffset,
+    122,
+    double.negativeInfinity,
+  );
+  double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(
+    _bc,
+    _bcOffset,
+    124,
+    double.negativeInfinity,
+  );
+  double get doubleInfDefault =>
+      const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
 
   @override
   String toString() {
@@ -1213,7 +1334,7 @@ class Monster {
       inventory: inventory?.toList(),
       color: color,
       testType: testType,
-      test: test?.unpack(),
+      test: test is String ? test : test?.unpack(),
       test4: test4?.map((e) => e.unpack()).toList(),
       testarrayofstring: testarrayofstring?.toList(),
       testarrayoftables: testarrayoftables?.map((e) => e.unpack()).toList(),
@@ -1249,9 +1370,9 @@ class Monster {
       nonOwningReference: nonOwningReference,
       vectorOfNonOwningReferences: vectorOfNonOwningReferences?.toList(),
       anyUniqueType: anyUniqueType,
-      anyUnique: anyUnique?.unpack(),
+      anyUnique: anyUnique is String ? anyUnique : anyUnique?.unpack(),
       anyAmbiguousType: anyAmbiguousType,
-      anyAmbiguous: anyAmbiguous?.unpack(),
+      anyAmbiguous: anyAmbiguous is String ? anyAmbiguous : anyAmbiguous?.unpack(),
       vectorOfEnums: vectorOfEnums?.toList(),
       signedEnum: signedEnum,
       testrequirednestedflatbuffer: testrequirednestedflatbuffer?.toList(),
@@ -1286,6 +1407,7 @@ class MonsterT implements fb.Packable {
   dynamic test;
   List<TestT>? test4;
   List<String>? testarrayofstring;
+
   ///  an example documentation comment: this will end up in the generated code
   ///  multiline too
   List<MonsterT>? testarrayoftables;
@@ -1341,127 +1463,160 @@ class MonsterT implements fb.Packable {
   double doubleInfDefault;
 
   MonsterT({
-      this.pos,
-      this.mana = 150,
-      this.hp = 100,
-      this.name,
-      this.inventory,
-      this.color = Color.Blue,
-      this.testType,
-      this.test,
-      this.test4,
-      this.testarrayofstring,
-      this.testarrayoftables,
-      this.enemy,
-      this.testnestedflatbuffer,
-      this.testempty,
-      this.testbool = false,
-      this.testhashs32Fnv1 = 0,
-      this.testhashu32Fnv1 = 0,
-      this.testhashs64Fnv1 = 0,
-      this.testhashu64Fnv1 = 0,
-      this.testhashs32Fnv1a = 0,
-      this.testhashu32Fnv1a = 0,
-      this.testhashs64Fnv1a = 0,
-      this.testhashu64Fnv1a = 0,
-      this.testarrayofbools,
-      this.testf = 3.14159,
-      this.testf2 = 3.0,
-      this.testf3 = 0.0,
-      this.testarrayofstring2,
-      this.testarrayofsortedstruct,
-      this.flex,
-      this.test5,
-      this.vectorOfLongs,
-      this.vectorOfDoubles,
-      this.parentNamespaceTest,
-      this.vectorOfReferrables,
-      this.singleWeakReference = 0,
-      this.vectorOfWeakReferences,
-      this.vectorOfStrongReferrables,
-      this.coOwningReference = 0,
-      this.vectorOfCoOwningReferences,
-      this.nonOwningReference = 0,
-      this.vectorOfNonOwningReferences,
-      this.anyUniqueType,
-      this.anyUnique,
-      this.anyAmbiguousType,
-      this.anyAmbiguous,
-      this.vectorOfEnums,
-      this.signedEnum = Race.None,
-      this.testrequirednestedflatbuffer,
-      this.scalarKeySortedTables,
-      this.nativeInline,
-      this.longEnumNonEnumDefault = LongEnum._default,
-      this.longEnumNormalDefault = LongEnum.LongOne,
-      this.nanDefault = double.nan,
-      this.infDefault = double.infinity,
-      this.positiveInfDefault = double.infinity,
-      this.infinityDefault = double.infinity,
-      this.positiveInfinityDefault = double.infinity,
-      this.negativeInfDefault = double.negativeInfinity,
-      this.negativeInfinityDefault = double.negativeInfinity,
-      this.doubleInfDefault = double.infinity});
+    this.pos,
+    this.mana = 150,
+    this.hp = 100,
+    this.name,
+    this.inventory,
+    this.color = Color.Blue,
+    this.testType,
+    this.test,
+    this.test4,
+    this.testarrayofstring,
+    this.testarrayoftables,
+    this.enemy,
+    this.testnestedflatbuffer,
+    this.testempty,
+    this.testbool = false,
+    this.testhashs32Fnv1 = 0,
+    this.testhashu32Fnv1 = 0,
+    this.testhashs64Fnv1 = 0,
+    this.testhashu64Fnv1 = 0,
+    this.testhashs32Fnv1a = 0,
+    this.testhashu32Fnv1a = 0,
+    this.testhashs64Fnv1a = 0,
+    this.testhashu64Fnv1a = 0,
+    this.testarrayofbools,
+    this.testf = 3.14159,
+    this.testf2 = 3.0,
+    this.testf3 = 0.0,
+    this.testarrayofstring2,
+    this.testarrayofsortedstruct,
+    this.flex,
+    this.test5,
+    this.vectorOfLongs,
+    this.vectorOfDoubles,
+    this.parentNamespaceTest,
+    this.vectorOfReferrables,
+    this.singleWeakReference = 0,
+    this.vectorOfWeakReferences,
+    this.vectorOfStrongReferrables,
+    this.coOwningReference = 0,
+    this.vectorOfCoOwningReferences,
+    this.nonOwningReference = 0,
+    this.vectorOfNonOwningReferences,
+    this.anyUniqueType,
+    this.anyUnique,
+    this.anyAmbiguousType,
+    this.anyAmbiguous,
+    this.vectorOfEnums,
+    this.signedEnum = Race.None,
+    this.testrequirednestedflatbuffer,
+    this.scalarKeySortedTables,
+    this.nativeInline,
+    this.longEnumNonEnumDefault = LongEnum._default,
+    this.longEnumNormalDefault = LongEnum.LongOne,
+    this.nanDefault = double.nan,
+    this.infDefault = double.infinity,
+    this.positiveInfDefault = double.infinity,
+    this.infinityDefault = double.infinity,
+    this.positiveInfinityDefault = double.infinity,
+    this.negativeInfDefault = double.negativeInfinity,
+    this.negativeInfinityDefault = double.negativeInfinity,
+    this.doubleInfDefault = double.infinity,
+  });
 
   @override
   int pack(fb.Builder fbBuilder) {
-    final int? nameOffset = name == null ? null
-        : fbBuilder.writeString(name!);
-    final int? inventoryOffset = inventory == null ? null
+    final int? nameOffset = name == null ? null : fbBuilder.writeString(name!);
+    final int? inventoryOffset = inventory == null
+        ? null
         : fbBuilder.writeListUint8(inventory!);
-    final int? testOffset = test?.pack(fbBuilder);
+    final int? testOffset = test is String ? fbBuilder.writeString(test) : test?.pack(fbBuilder);
     int? test4Offset;
     if (test4 != null) {
       for (var e in test4!.reversed) { e.pack(fbBuilder); }
       test4Offset = fbBuilder.endStructVector(test4!.length);
     }
-    final int? testarrayofstringOffset = testarrayofstring == null ? null
-        : fbBuilder.writeList(testarrayofstring!.map(fbBuilder.writeString).toList());
-    final int? testarrayoftablesOffset = testarrayoftables == null ? null
-        : fbBuilder.writeList(testarrayoftables!.map((b) => b.pack(fbBuilder)).toList());
+    final int? testarrayofstringOffset = testarrayofstring == null
+        ? null
+        : fbBuilder.writeList(
+            testarrayofstring!.map(fbBuilder.writeString).toList(),
+          );
+    final int? testarrayoftablesOffset = testarrayoftables == null
+        ? null
+        : fbBuilder.writeList(
+            testarrayoftables!.map((b) => b.pack(fbBuilder)).toList(),
+          );
     final int? enemyOffset = enemy?.pack(fbBuilder);
-    final int? testnestedflatbufferOffset = testnestedflatbuffer == null ? null
+    final int? testnestedflatbufferOffset = testnestedflatbuffer == null
+        ? null
         : fbBuilder.writeListUint8(testnestedflatbuffer!);
     final int? testemptyOffset = testempty?.pack(fbBuilder);
-    final int? testarrayofboolsOffset = testarrayofbools == null ? null
+    final int? testarrayofboolsOffset = testarrayofbools == null
+        ? null
         : fbBuilder.writeListBool(testarrayofbools!);
-    final int? testarrayofstring2Offset = testarrayofstring2 == null ? null
-        : fbBuilder.writeList(testarrayofstring2!.map(fbBuilder.writeString).toList());
+    final int? testarrayofstring2Offset = testarrayofstring2 == null
+        ? null
+        : fbBuilder.writeList(
+            testarrayofstring2!.map(fbBuilder.writeString).toList(),
+          );
     int? testarrayofsortedstructOffset;
     if (testarrayofsortedstruct != null) {
       for (var e in testarrayofsortedstruct!.reversed) { e.pack(fbBuilder); }
       testarrayofsortedstructOffset = fbBuilder.endStructVector(testarrayofsortedstruct!.length);
     }
-    final int? flexOffset = flex == null ? null
+    final int? flexOffset = flex == null
+        ? null
         : fbBuilder.writeListUint8(flex!);
     int? test5Offset;
     if (test5 != null) {
       for (var e in test5!.reversed) { e.pack(fbBuilder); }
       test5Offset = fbBuilder.endStructVector(test5!.length);
     }
-    final int? vectorOfLongsOffset = vectorOfLongs == null ? null
+    final int? vectorOfLongsOffset = vectorOfLongs == null
+        ? null
         : fbBuilder.writeListInt64(vectorOfLongs!);
-    final int? vectorOfDoublesOffset = vectorOfDoubles == null ? null
+    final int? vectorOfDoublesOffset = vectorOfDoubles == null
+        ? null
         : fbBuilder.writeListFloat64(vectorOfDoubles!);
     final int? parentNamespaceTestOffset = parentNamespaceTest?.pack(fbBuilder);
-    final int? vectorOfReferrablesOffset = vectorOfReferrables == null ? null
-        : fbBuilder.writeList(vectorOfReferrables!.map((b) => b.pack(fbBuilder)).toList());
-    final int? vectorOfWeakReferencesOffset = vectorOfWeakReferences == null ? null
+    final int? vectorOfReferrablesOffset = vectorOfReferrables == null
+        ? null
+        : fbBuilder.writeList(
+            vectorOfReferrables!.map((b) => b.pack(fbBuilder)).toList(),
+          );
+    final int? vectorOfWeakReferencesOffset = vectorOfWeakReferences == null
+        ? null
         : fbBuilder.writeListUint64(vectorOfWeakReferences!);
-    final int? vectorOfStrongReferrablesOffset = vectorOfStrongReferrables == null ? null
-        : fbBuilder.writeList(vectorOfStrongReferrables!.map((b) => b.pack(fbBuilder)).toList());
-    final int? vectorOfCoOwningReferencesOffset = vectorOfCoOwningReferences == null ? null
+    final int? vectorOfStrongReferrablesOffset =
+        vectorOfStrongReferrables == null
+        ? null
+        : fbBuilder.writeList(
+            vectorOfStrongReferrables!.map((b) => b.pack(fbBuilder)).toList(),
+          );
+    final int? vectorOfCoOwningReferencesOffset =
+        vectorOfCoOwningReferences == null
+        ? null
         : fbBuilder.writeListUint64(vectorOfCoOwningReferences!);
-    final int? vectorOfNonOwningReferencesOffset = vectorOfNonOwningReferences == null ? null
+    final int? vectorOfNonOwningReferencesOffset =
+        vectorOfNonOwningReferences == null
+        ? null
         : fbBuilder.writeListUint64(vectorOfNonOwningReferences!);
-    final int? anyUniqueOffset = anyUnique?.pack(fbBuilder);
-    final int? anyAmbiguousOffset = anyAmbiguous?.pack(fbBuilder);
-    final int? vectorOfEnumsOffset = vectorOfEnums == null ? null
+    final int? anyUniqueOffset = anyUnique is String ? fbBuilder.writeString(anyUnique) : anyUnique?.pack(fbBuilder);
+    final int? anyAmbiguousOffset = anyAmbiguous is String ? fbBuilder.writeString(anyAmbiguous) : anyAmbiguous?.pack(fbBuilder);
+    final int? vectorOfEnumsOffset = vectorOfEnums == null
+        ? null
         : fbBuilder.writeListUint8(vectorOfEnums!.map((f) => f.value).toList());
-    final int? testrequirednestedflatbufferOffset = testrequirednestedflatbuffer == null ? null
+    final int? testrequirednestedflatbufferOffset =
+        testrequirednestedflatbuffer == null
+        ? null
         : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
-    final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null ? null
-        : fbBuilder.writeList(scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList());
+    final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null
+        ? null
+        : fbBuilder.writeList(
+            scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList(),
+          );
     fbBuilder.startTable(62);
     if (pos != null) {
       fbBuilder.addStruct(0, pos!.pack(fbBuilder));
@@ -1541,8 +1696,8 @@ class _MonsterReader extends fb.TableReader<Monster> {
   const _MonsterReader();
 
   @override
-  Monster createObject(fb.BufferContext bc, int offset) => 
-    Monster._(bc, offset);
+  Monster createObject(fb.BufferContext bc, int offset) =>
+      Monster._(bc, offset);
 }
 
 class MonsterBuilder {
@@ -1558,242 +1713,302 @@ class MonsterBuilder {
     fbBuilder.addStruct(0, offset);
     return fbBuilder.offset;
   }
+
   int addMana(int? mana) {
     fbBuilder.addInt16(1, mana);
     return fbBuilder.offset;
   }
+
   int addHp(int? hp) {
     fbBuilder.addInt16(2, hp);
     return fbBuilder.offset;
   }
+
   int addNameOffset(int? offset) {
     fbBuilder.addOffset(3, offset);
     return fbBuilder.offset;
   }
+
   int addInventoryOffset(int? offset) {
     fbBuilder.addOffset(5, offset);
     return fbBuilder.offset;
   }
+
   int addColor(Color? color) {
     fbBuilder.addUint8(6, color?.value);
     return fbBuilder.offset;
   }
+
   int addTestType(AnyTypeId? testType) {
     fbBuilder.addUint8(7, testType?.value);
     return fbBuilder.offset;
   }
+
   int addTestOffset(int? offset) {
     fbBuilder.addOffset(8, offset);
     return fbBuilder.offset;
   }
+
   int addTest4Offset(int? offset) {
     fbBuilder.addOffset(9, offset);
     return fbBuilder.offset;
   }
+
   int addTestarrayofstringOffset(int? offset) {
     fbBuilder.addOffset(10, offset);
     return fbBuilder.offset;
   }
+
   int addTestarrayoftablesOffset(int? offset) {
     fbBuilder.addOffset(11, offset);
     return fbBuilder.offset;
   }
+
   int addEnemyOffset(int? offset) {
     fbBuilder.addOffset(12, offset);
     return fbBuilder.offset;
   }
+
   int addTestnestedflatbufferOffset(int? offset) {
     fbBuilder.addOffset(13, offset);
     return fbBuilder.offset;
   }
+
   int addTestemptyOffset(int? offset) {
     fbBuilder.addOffset(14, offset);
     return fbBuilder.offset;
   }
+
   int addTestbool(bool? testbool) {
     fbBuilder.addBool(15, testbool);
     return fbBuilder.offset;
   }
+
   int addTesthashs32Fnv1(int? testhashs32Fnv1) {
     fbBuilder.addInt32(16, testhashs32Fnv1);
     return fbBuilder.offset;
   }
+
   int addTesthashu32Fnv1(int? testhashu32Fnv1) {
     fbBuilder.addUint32(17, testhashu32Fnv1);
     return fbBuilder.offset;
   }
+
   int addTesthashs64Fnv1(int? testhashs64Fnv1) {
     fbBuilder.addInt64(18, testhashs64Fnv1);
     return fbBuilder.offset;
   }
+
   int addTesthashu64Fnv1(int? testhashu64Fnv1) {
     fbBuilder.addUint64(19, testhashu64Fnv1);
     return fbBuilder.offset;
   }
+
   int addTesthashs32Fnv1a(int? testhashs32Fnv1a) {
     fbBuilder.addInt32(20, testhashs32Fnv1a);
     return fbBuilder.offset;
   }
+
   int addTesthashu32Fnv1a(int? testhashu32Fnv1a) {
     fbBuilder.addUint32(21, testhashu32Fnv1a);
     return fbBuilder.offset;
   }
+
   int addTesthashs64Fnv1a(int? testhashs64Fnv1a) {
     fbBuilder.addInt64(22, testhashs64Fnv1a);
     return fbBuilder.offset;
   }
+
   int addTesthashu64Fnv1a(int? testhashu64Fnv1a) {
     fbBuilder.addUint64(23, testhashu64Fnv1a);
     return fbBuilder.offset;
   }
+
   int addTestarrayofboolsOffset(int? offset) {
     fbBuilder.addOffset(24, offset);
     return fbBuilder.offset;
   }
+
   int addTestf(double? testf) {
     fbBuilder.addFloat32(25, testf);
     return fbBuilder.offset;
   }
+
   int addTestf2(double? testf2) {
     fbBuilder.addFloat32(26, testf2);
     return fbBuilder.offset;
   }
+
   int addTestf3(double? testf3) {
     fbBuilder.addFloat32(27, testf3);
     return fbBuilder.offset;
   }
+
   int addTestarrayofstring2Offset(int? offset) {
     fbBuilder.addOffset(28, offset);
     return fbBuilder.offset;
   }
+
   int addTestarrayofsortedstructOffset(int? offset) {
     fbBuilder.addOffset(29, offset);
     return fbBuilder.offset;
   }
+
   int addFlexOffset(int? offset) {
     fbBuilder.addOffset(30, offset);
     return fbBuilder.offset;
   }
+
   int addTest5Offset(int? offset) {
     fbBuilder.addOffset(31, offset);
     return fbBuilder.offset;
   }
+
   int addVectorOfLongsOffset(int? offset) {
     fbBuilder.addOffset(32, offset);
     return fbBuilder.offset;
   }
+
   int addVectorOfDoublesOffset(int? offset) {
     fbBuilder.addOffset(33, offset);
     return fbBuilder.offset;
   }
+
   int addParentNamespaceTestOffset(int? offset) {
     fbBuilder.addOffset(34, offset);
     return fbBuilder.offset;
   }
+
   int addVectorOfReferrablesOffset(int? offset) {
     fbBuilder.addOffset(35, offset);
     return fbBuilder.offset;
   }
+
   int addSingleWeakReference(int? singleWeakReference) {
     fbBuilder.addUint64(36, singleWeakReference);
     return fbBuilder.offset;
   }
+
   int addVectorOfWeakReferencesOffset(int? offset) {
     fbBuilder.addOffset(37, offset);
     return fbBuilder.offset;
   }
+
   int addVectorOfStrongReferrablesOffset(int? offset) {
     fbBuilder.addOffset(38, offset);
     return fbBuilder.offset;
   }
+
   int addCoOwningReference(int? coOwningReference) {
     fbBuilder.addUint64(39, coOwningReference);
     return fbBuilder.offset;
   }
+
   int addVectorOfCoOwningReferencesOffset(int? offset) {
     fbBuilder.addOffset(40, offset);
     return fbBuilder.offset;
   }
+
   int addNonOwningReference(int? nonOwningReference) {
     fbBuilder.addUint64(41, nonOwningReference);
     return fbBuilder.offset;
   }
+
   int addVectorOfNonOwningReferencesOffset(int? offset) {
     fbBuilder.addOffset(42, offset);
     return fbBuilder.offset;
   }
+
   int addAnyUniqueType(AnyUniqueAliasesTypeId? anyUniqueType) {
     fbBuilder.addUint8(43, anyUniqueType?.value);
     return fbBuilder.offset;
   }
+
   int addAnyUniqueOffset(int? offset) {
     fbBuilder.addOffset(44, offset);
     return fbBuilder.offset;
   }
+
   int addAnyAmbiguousType(AnyAmbiguousAliasesTypeId? anyAmbiguousType) {
     fbBuilder.addUint8(45, anyAmbiguousType?.value);
     return fbBuilder.offset;
   }
+
   int addAnyAmbiguousOffset(int? offset) {
     fbBuilder.addOffset(46, offset);
     return fbBuilder.offset;
   }
+
   int addVectorOfEnumsOffset(int? offset) {
     fbBuilder.addOffset(47, offset);
     return fbBuilder.offset;
   }
+
   int addSignedEnum(Race? signedEnum) {
     fbBuilder.addInt8(48, signedEnum?.value);
     return fbBuilder.offset;
   }
+
   int addTestrequirednestedflatbufferOffset(int? offset) {
     fbBuilder.addOffset(49, offset);
     return fbBuilder.offset;
   }
+
   int addScalarKeySortedTablesOffset(int? offset) {
     fbBuilder.addOffset(50, offset);
     return fbBuilder.offset;
   }
+
   int addNativeInline(int offset) {
     fbBuilder.addStruct(51, offset);
     return fbBuilder.offset;
   }
+
   int addLongEnumNonEnumDefault(LongEnum? longEnumNonEnumDefault) {
     fbBuilder.addUint64(52, longEnumNonEnumDefault?.value);
     return fbBuilder.offset;
   }
+
   int addLongEnumNormalDefault(LongEnum? longEnumNormalDefault) {
     fbBuilder.addUint64(53, longEnumNormalDefault?.value);
     return fbBuilder.offset;
   }
+
   int addNanDefault(double? nanDefault) {
     fbBuilder.addFloat32(54, nanDefault);
     return fbBuilder.offset;
   }
+
   int addInfDefault(double? infDefault) {
     fbBuilder.addFloat32(55, infDefault);
     return fbBuilder.offset;
   }
+
   int addPositiveInfDefault(double? positiveInfDefault) {
     fbBuilder.addFloat32(56, positiveInfDefault);
     return fbBuilder.offset;
   }
+
   int addInfinityDefault(double? infinityDefault) {
     fbBuilder.addFloat32(57, infinityDefault);
     return fbBuilder.offset;
   }
+
   int addPositiveInfinityDefault(double? positiveInfinityDefault) {
     fbBuilder.addFloat32(58, positiveInfinityDefault);
     return fbBuilder.offset;
   }
+
   int addNegativeInfDefault(double? negativeInfDefault) {
     fbBuilder.addFloat32(59, negativeInfDefault);
     return fbBuilder.offset;
   }
+
   int addNegativeInfinityDefault(double? negativeInfinityDefault) {
     fbBuilder.addFloat32(60, negativeInfinityDefault);
     return fbBuilder.offset;
   }
+
   int addDoubleInfDefault(double? doubleInfDefault) {
     fbBuilder.addFloat64(61, doubleInfDefault);
     return fbBuilder.offset;
@@ -1929,120 +2144,167 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     double? negativeInfDefault,
     double? negativeInfinityDefault,
     double? doubleInfDefault,
-  })
-      : _pos = pos,
-        _mana = mana,
-        _hp = hp,
-        _name = name,
-        _inventory = inventory,
-        _color = color,
-        _testType = testType,
-        _test = test,
-        _test4 = test4,
-        _testarrayofstring = testarrayofstring,
-        _testarrayoftables = testarrayoftables,
-        _enemy = enemy,
-        _testnestedflatbuffer = testnestedflatbuffer,
-        _testempty = testempty,
-        _testbool = testbool,
-        _testhashs32Fnv1 = testhashs32Fnv1,
-        _testhashu32Fnv1 = testhashu32Fnv1,
-        _testhashs64Fnv1 = testhashs64Fnv1,
-        _testhashu64Fnv1 = testhashu64Fnv1,
-        _testhashs32Fnv1a = testhashs32Fnv1a,
-        _testhashu32Fnv1a = testhashu32Fnv1a,
-        _testhashs64Fnv1a = testhashs64Fnv1a,
-        _testhashu64Fnv1a = testhashu64Fnv1a,
-        _testarrayofbools = testarrayofbools,
-        _testf = testf,
-        _testf2 = testf2,
-        _testf3 = testf3,
-        _testarrayofstring2 = testarrayofstring2,
-        _testarrayofsortedstruct = testarrayofsortedstruct,
-        _flex = flex,
-        _test5 = test5,
-        _vectorOfLongs = vectorOfLongs,
-        _vectorOfDoubles = vectorOfDoubles,
-        _parentNamespaceTest = parentNamespaceTest,
-        _vectorOfReferrables = vectorOfReferrables,
-        _singleWeakReference = singleWeakReference,
-        _vectorOfWeakReferences = vectorOfWeakReferences,
-        _vectorOfStrongReferrables = vectorOfStrongReferrables,
-        _coOwningReference = coOwningReference,
-        _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
-        _nonOwningReference = nonOwningReference,
-        _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
-        _anyUniqueType = anyUniqueType,
-        _anyUnique = anyUnique,
-        _anyAmbiguousType = anyAmbiguousType,
-        _anyAmbiguous = anyAmbiguous,
-        _vectorOfEnums = vectorOfEnums,
-        _signedEnum = signedEnum,
-        _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
-        _scalarKeySortedTables = scalarKeySortedTables,
-        _nativeInline = nativeInline,
-        _longEnumNonEnumDefault = longEnumNonEnumDefault,
-        _longEnumNormalDefault = longEnumNormalDefault,
-        _nanDefault = nanDefault,
-        _infDefault = infDefault,
-        _positiveInfDefault = positiveInfDefault,
-        _infinityDefault = infinityDefault,
-        _positiveInfinityDefault = positiveInfinityDefault,
-        _negativeInfDefault = negativeInfDefault,
-        _negativeInfinityDefault = negativeInfinityDefault,
-        _doubleInfDefault = doubleInfDefault;
+  }) : _pos = pos,
+       _mana = mana,
+       _hp = hp,
+       _name = name,
+       _inventory = inventory,
+       _color = color,
+       _testType = testType,
+       _test = test,
+       _test4 = test4,
+       _testarrayofstring = testarrayofstring,
+       _testarrayoftables = testarrayoftables,
+       _enemy = enemy,
+       _testnestedflatbuffer = testnestedflatbuffer,
+       _testempty = testempty,
+       _testbool = testbool,
+       _testhashs32Fnv1 = testhashs32Fnv1,
+       _testhashu32Fnv1 = testhashu32Fnv1,
+       _testhashs64Fnv1 = testhashs64Fnv1,
+       _testhashu64Fnv1 = testhashu64Fnv1,
+       _testhashs32Fnv1a = testhashs32Fnv1a,
+       _testhashu32Fnv1a = testhashu32Fnv1a,
+       _testhashs64Fnv1a = testhashs64Fnv1a,
+       _testhashu64Fnv1a = testhashu64Fnv1a,
+       _testarrayofbools = testarrayofbools,
+       _testf = testf,
+       _testf2 = testf2,
+       _testf3 = testf3,
+       _testarrayofstring2 = testarrayofstring2,
+       _testarrayofsortedstruct = testarrayofsortedstruct,
+       _flex = flex,
+       _test5 = test5,
+       _vectorOfLongs = vectorOfLongs,
+       _vectorOfDoubles = vectorOfDoubles,
+       _parentNamespaceTest = parentNamespaceTest,
+       _vectorOfReferrables = vectorOfReferrables,
+       _singleWeakReference = singleWeakReference,
+       _vectorOfWeakReferences = vectorOfWeakReferences,
+       _vectorOfStrongReferrables = vectorOfStrongReferrables,
+       _coOwningReference = coOwningReference,
+       _vectorOfCoOwningReferences = vectorOfCoOwningReferences,
+       _nonOwningReference = nonOwningReference,
+       _vectorOfNonOwningReferences = vectorOfNonOwningReferences,
+       _anyUniqueType = anyUniqueType,
+       _anyUnique = anyUnique,
+       _anyAmbiguousType = anyAmbiguousType,
+       _anyAmbiguous = anyAmbiguous,
+       _vectorOfEnums = vectorOfEnums,
+       _signedEnum = signedEnum,
+       _testrequirednestedflatbuffer = testrequirednestedflatbuffer,
+       _scalarKeySortedTables = scalarKeySortedTables,
+       _nativeInline = nativeInline,
+       _longEnumNonEnumDefault = longEnumNonEnumDefault,
+       _longEnumNormalDefault = longEnumNormalDefault,
+       _nanDefault = nanDefault,
+       _infDefault = infDefault,
+       _positiveInfDefault = positiveInfDefault,
+       _infinityDefault = infinityDefault,
+       _positiveInfinityDefault = positiveInfinityDefault,
+       _negativeInfDefault = negativeInfDefault,
+       _negativeInfinityDefault = negativeInfinityDefault,
+       _doubleInfDefault = doubleInfDefault;
 
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
-    final int? nameOffset = _name == null ? null
+    final int? nameOffset = _name == null
+        ? null
         : fbBuilder.writeString(_name!);
-    final int? inventoryOffset = _inventory == null ? null
+    final int? inventoryOffset = _inventory == null
+        ? null
         : fbBuilder.writeListUint8(_inventory!);
-    final int? testOffset = _test?.getOrCreateOffset(fbBuilder);
-    final int? test4Offset = _test4 == null ? null
+    final int? testOffset = _test is String ? fbBuilder.writeString(_test) : _test?.getOrCreateOffset(fbBuilder);
+    final int? test4Offset = _test4 == null
+        ? null
         : fbBuilder.writeListOfStructs(_test4!);
-    final int? testarrayofstringOffset = _testarrayofstring == null ? null
-        : fbBuilder.writeList(_testarrayofstring!.map(fbBuilder.writeString).toList());
-    final int? testarrayoftablesOffset = _testarrayoftables == null ? null
-        : fbBuilder.writeList(_testarrayoftables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
+    final int? testarrayofstringOffset = _testarrayofstring == null
+        ? null
+        : fbBuilder.writeList(
+            _testarrayofstring!.map(fbBuilder.writeString).toList(),
+          );
+    final int? testarrayoftablesOffset = _testarrayoftables == null
+        ? null
+        : fbBuilder.writeList(
+            _testarrayoftables!
+                .map((b) => b.getOrCreateOffset(fbBuilder))
+                .toList(),
+          );
     final int? enemyOffset = _enemy?.getOrCreateOffset(fbBuilder);
-    final int? testnestedflatbufferOffset = _testnestedflatbuffer == null ? null
+    final int? testnestedflatbufferOffset = _testnestedflatbuffer == null
+        ? null
         : fbBuilder.writeListUint8(_testnestedflatbuffer!);
     final int? testemptyOffset = _testempty?.getOrCreateOffset(fbBuilder);
-    final int? testarrayofboolsOffset = _testarrayofbools == null ? null
+    final int? testarrayofboolsOffset = _testarrayofbools == null
+        ? null
         : fbBuilder.writeListBool(_testarrayofbools!);
-    final int? testarrayofstring2Offset = _testarrayofstring2 == null ? null
-        : fbBuilder.writeList(_testarrayofstring2!.map(fbBuilder.writeString).toList());
-    final int? testarrayofsortedstructOffset = _testarrayofsortedstruct == null ? null
+    final int? testarrayofstring2Offset = _testarrayofstring2 == null
+        ? null
+        : fbBuilder.writeList(
+            _testarrayofstring2!.map(fbBuilder.writeString).toList(),
+          );
+    final int? testarrayofsortedstructOffset = _testarrayofsortedstruct == null
+        ? null
         : fbBuilder.writeListOfStructs(_testarrayofsortedstruct!);
-    final int? flexOffset = _flex == null ? null
+    final int? flexOffset = _flex == null
+        ? null
         : fbBuilder.writeListUint8(_flex!);
-    final int? test5Offset = _test5 == null ? null
+    final int? test5Offset = _test5 == null
+        ? null
         : fbBuilder.writeListOfStructs(_test5!);
-    final int? vectorOfLongsOffset = _vectorOfLongs == null ? null
+    final int? vectorOfLongsOffset = _vectorOfLongs == null
+        ? null
         : fbBuilder.writeListInt64(_vectorOfLongs!);
-    final int? vectorOfDoublesOffset = _vectorOfDoubles == null ? null
+    final int? vectorOfDoublesOffset = _vectorOfDoubles == null
+        ? null
         : fbBuilder.writeListFloat64(_vectorOfDoubles!);
-    final int? parentNamespaceTestOffset = _parentNamespaceTest?.getOrCreateOffset(fbBuilder);
-    final int? vectorOfReferrablesOffset = _vectorOfReferrables == null ? null
-        : fbBuilder.writeList(_vectorOfReferrables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
-    final int? vectorOfWeakReferencesOffset = _vectorOfWeakReferences == null ? null
+    final int? parentNamespaceTestOffset = _parentNamespaceTest
+        ?.getOrCreateOffset(fbBuilder);
+    final int? vectorOfReferrablesOffset = _vectorOfReferrables == null
+        ? null
+        : fbBuilder.writeList(
+            _vectorOfReferrables!
+                .map((b) => b.getOrCreateOffset(fbBuilder))
+                .toList(),
+          );
+    final int? vectorOfWeakReferencesOffset = _vectorOfWeakReferences == null
+        ? null
         : fbBuilder.writeListUint64(_vectorOfWeakReferences!);
-    final int? vectorOfStrongReferrablesOffset = _vectorOfStrongReferrables == null ? null
-        : fbBuilder.writeList(_vectorOfStrongReferrables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
-    final int? vectorOfCoOwningReferencesOffset = _vectorOfCoOwningReferences == null ? null
+    final int? vectorOfStrongReferrablesOffset =
+        _vectorOfStrongReferrables == null
+        ? null
+        : fbBuilder.writeList(
+            _vectorOfStrongReferrables!
+                .map((b) => b.getOrCreateOffset(fbBuilder))
+                .toList(),
+          );
+    final int? vectorOfCoOwningReferencesOffset =
+        _vectorOfCoOwningReferences == null
+        ? null
         : fbBuilder.writeListUint64(_vectorOfCoOwningReferences!);
-    final int? vectorOfNonOwningReferencesOffset = _vectorOfNonOwningReferences == null ? null
+    final int? vectorOfNonOwningReferencesOffset =
+        _vectorOfNonOwningReferences == null
+        ? null
         : fbBuilder.writeListUint64(_vectorOfNonOwningReferences!);
-    final int? anyUniqueOffset = _anyUnique?.getOrCreateOffset(fbBuilder);
-    final int? anyAmbiguousOffset = _anyAmbiguous?.getOrCreateOffset(fbBuilder);
-    final int? vectorOfEnumsOffset = _vectorOfEnums == null ? null
-        : fbBuilder.writeListUint8(_vectorOfEnums!.map((f) => f.value).toList());
-    final int? testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer == null ? null
+    final int? anyUniqueOffset = _anyUnique is String ? fbBuilder.writeString(_anyUnique) : _anyUnique?.getOrCreateOffset(fbBuilder);
+    final int? anyAmbiguousOffset = _anyAmbiguous is String ? fbBuilder.writeString(_anyAmbiguous) : _anyAmbiguous?.getOrCreateOffset(fbBuilder);
+    final int? vectorOfEnumsOffset = _vectorOfEnums == null
+        ? null
+        : fbBuilder.writeListUint8(
+            _vectorOfEnums!.map((f) => f.value).toList(),
+          );
+    final int? testrequirednestedflatbufferOffset =
+        _testrequirednestedflatbuffer == null
+        ? null
         : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
-    final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null ? null
-        : fbBuilder.writeList(_scalarKeySortedTables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
+    final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null
+        ? null
+        : fbBuilder.writeList(
+            _scalarKeySortedTables!
+                .map((b) => b.getOrCreateOffset(fbBuilder))
+                .toList(),
+          );
     fbBuilder.startTable(62);
     if (_pos != null) {
       fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
@@ -2120,6 +2382,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     return fbBuilder.buffer;
   }
 }
+
 class TypeAliases {
   TypeAliases._(this._bc, this._bcOffset);
   factory TypeAliases(List<int> bytes) {
@@ -2142,8 +2405,10 @@ class TypeAliases {
   int get u64 => const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 18, 0);
   double get f32 => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 20, 0.0);
   double get f64 => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 22, 0.0);
-  List<int>? get v8 => const fb.Int8ListReader().vTableGetNullable(_bc, _bcOffset, 24);
-  List<double>? get vf64 => const fb.ListReader<double>(fb.Float64Reader()).vTableGetNullable(_bc, _bcOffset, 26);
+  List<int>? get v8 => const fb.ListReader<int>(fb.Int8Reader()).vTableGetNullable(_bc, _bcOffset, 24);
+  List<double>? get vf64 => const fb.ListReader<double>(
+    fb.Float64Reader(),
+  ).vTableGetNullable(_bc, _bcOffset, 26);
 
   @override
   String toString() {
@@ -2185,24 +2450,25 @@ class TypeAliasesT implements fb.Packable {
   List<double>? vf64;
 
   TypeAliasesT({
-      this.i8 = 0,
-      this.u8 = 0,
-      this.i16 = 0,
-      this.u16 = 0,
-      this.i32 = 0,
-      this.u32 = 0,
-      this.i64 = 0,
-      this.u64 = 0,
-      this.f32 = 0.0,
-      this.f64 = 0.0,
-      this.v8,
-      this.vf64});
+    this.i8 = 0,
+    this.u8 = 0,
+    this.i16 = 0,
+    this.u16 = 0,
+    this.i32 = 0,
+    this.u32 = 0,
+    this.i64 = 0,
+    this.u64 = 0,
+    this.f32 = 0.0,
+    this.f64 = 0.0,
+    this.v8,
+    this.vf64,
+  });
 
   @override
   int pack(fb.Builder fbBuilder) {
-    final int? v8Offset = v8 == null ? null
-        : fbBuilder.writeListInt8(v8!);
-    final int? vf64Offset = vf64 == null ? null
+    final int? v8Offset = v8 == null ? null : fbBuilder.writeListInt8(v8!);
+    final int? vf64Offset = vf64 == null
+        ? null
         : fbBuilder.writeListFloat64(vf64!);
     fbBuilder.startTable(12);
     fbBuilder.addInt8(0, i8);
@@ -2230,8 +2496,8 @@ class _TypeAliasesReader extends fb.TableReader<TypeAliases> {
   const _TypeAliasesReader();
 
   @override
-  TypeAliases createObject(fb.BufferContext bc, int offset) => 
-    TypeAliases._(bc, offset);
+  TypeAliases createObject(fb.BufferContext bc, int offset) =>
+      TypeAliases._(bc, offset);
 }
 
 class TypeAliasesBuilder {
@@ -2247,46 +2513,57 @@ class TypeAliasesBuilder {
     fbBuilder.addInt8(0, i8);
     return fbBuilder.offset;
   }
+
   int addU8(int? u8) {
     fbBuilder.addUint8(1, u8);
     return fbBuilder.offset;
   }
+
   int addI16(int? i16) {
     fbBuilder.addInt16(2, i16);
     return fbBuilder.offset;
   }
+
   int addU16(int? u16) {
     fbBuilder.addUint16(3, u16);
     return fbBuilder.offset;
   }
+
   int addI32(int? i32) {
     fbBuilder.addInt32(4, i32);
     return fbBuilder.offset;
   }
+
   int addU32(int? u32) {
     fbBuilder.addUint32(5, u32);
     return fbBuilder.offset;
   }
+
   int addI64(int? i64) {
     fbBuilder.addInt64(6, i64);
     return fbBuilder.offset;
   }
+
   int addU64(int? u64) {
     fbBuilder.addUint64(7, u64);
     return fbBuilder.offset;
   }
+
   int addF32(double? f32) {
     fbBuilder.addFloat32(8, f32);
     return fbBuilder.offset;
   }
+
   int addF64(double? f64) {
     fbBuilder.addFloat64(9, f64);
     return fbBuilder.offset;
   }
+
   int addV8Offset(int? offset) {
     fbBuilder.addOffset(10, offset);
     return fbBuilder.offset;
   }
+
   int addVf64Offset(int? offset) {
     fbBuilder.addOffset(11, offset);
     return fbBuilder.offset;
@@ -2324,26 +2601,25 @@ class TypeAliasesObjectBuilder extends fb.ObjectBuilder {
     double? f64,
     List<int>? v8,
     List<double>? vf64,
-  })
-      : _i8 = i8,
-        _u8 = u8,
-        _i16 = i16,
-        _u16 = u16,
-        _i32 = i32,
-        _u32 = u32,
-        _i64 = i64,
-        _u64 = u64,
-        _f32 = f32,
-        _f64 = f64,
-        _v8 = v8,
-        _vf64 = vf64;
+  }) : _i8 = i8,
+       _u8 = u8,
+       _i16 = i16,
+       _u16 = u16,
+       _i32 = i32,
+       _u32 = u32,
+       _i64 = i64,
+       _u64 = u64,
+       _f32 = f32,
+       _f64 = f64,
+       _v8 = v8,
+       _vf64 = vf64;
 
   /// Finish building, and store into the [fbBuilder].
   @override
   int finish(fb.Builder fbBuilder) {
-    final int? v8Offset = _v8 == null ? null
-        : fbBuilder.writeListInt8(_v8!);
-    final int? vf64Offset = _vf64 == null ? null
+    final int? v8Offset = _v8 == null ? null : fbBuilder.writeListInt8(_v8!);
+    final int? vf64Offset = _vf64 == null
+        ? null
         : fbBuilder.writeListFloat64(_vf64!);
     fbBuilder.startTable(12);
     fbBuilder.addInt8(0, _i8);
diff --git a/tests/union_vector/union_vector_generated.dart b/tests/union_vector/union_vector_generated.dart
new file mode 100644
index 00000000000..1c287bd6eb7
--- /dev/null
+++ b/tests/union_vector/union_vector_generated.dart
@@ -0,0 +1,722 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+
+import 'dart:typed_data' show Uint8List;
+import 'package:flat_buffers/flat_buffers.dart' as fb;
+
+
+enum CharacterTypeId {
+  NONE(0),
+  MuLan(1),
+  Rapunzel(2),
+  Belle(3),
+  BookFan(4),
+  Other(5),
+  Unused(6);
+
+  final int value;
+  const CharacterTypeId(this.value);
+
+  factory CharacterTypeId.fromValue(int value) {
+    switch (value) {
+      case 0: return CharacterTypeId.NONE;
+      case 1: return CharacterTypeId.MuLan;
+      case 2: return CharacterTypeId.Rapunzel;
+      case 3: return CharacterTypeId.Belle;
+      case 4: return CharacterTypeId.BookFan;
+      case 5: return CharacterTypeId.Other;
+      case 6: return CharacterTypeId.Unused;
+      default: throw StateError('Invalid value $value for bit flag enum');
+    }
+  }
+
+  static CharacterTypeId? _createOrNull(int? value) =>
+      value == null ? null : CharacterTypeId.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 6;
+  static const fb.Reader<CharacterTypeId> reader = _CharacterTypeIdReader();
+}
+
+class _CharacterTypeIdReader extends fb.Reader<CharacterTypeId> {
+  const _CharacterTypeIdReader();
+
+  @override
+  int get size => 1;
+
+  @override
+  CharacterTypeId read(fb.BufferContext bc, int offset) =>
+      CharacterTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+}
+
+class _CharacterReader extends fb.UnionReader {
+  _CharacterReader(CharacterTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(CharacterTypeId? type) {
+    switch (type?.value) {
+      case 1: return Attacker.reader;
+      case 2: return Rapunzel.reader;
+      case 3: return BookReader.reader;
+      case 4: return BookReader.reader;
+      case 5: return fb.StringReader();
+      case 6: return fb.StringReader();
+      default: return null;
+    }
+  }
+}
+
+enum GadgetTypeId {
+  NONE(0),
+  FallingTub(1),
+  HandFan(2);
+
+  final int value;
+  const GadgetTypeId(this.value);
+
+  factory GadgetTypeId.fromValue(int value) {
+    switch (value) {
+      case 0: return GadgetTypeId.NONE;
+      case 1: return GadgetTypeId.FallingTub;
+      case 2: return GadgetTypeId.HandFan;
+      default: throw StateError('Invalid value $value for bit flag enum');
+    }
+  }
+
+  static GadgetTypeId? _createOrNull(int? value) =>
+      value == null ? null : GadgetTypeId.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 2;
+  static const fb.Reader<GadgetTypeId> reader = _GadgetTypeIdReader();
+}
+
+class _GadgetTypeIdReader extends fb.Reader<GadgetTypeId> {
+  const _GadgetTypeIdReader();
+
+  @override
+  int get size => 1;
+
+  @override
+  GadgetTypeId read(fb.BufferContext bc, int offset) =>
+      GadgetTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+}
+
+class _GadgetReader extends fb.UnionReader {
+  _GadgetReader(GadgetTypeId? type) : super(_get(type));
+
+  static fb.Reader? _get(GadgetTypeId? type) {
+    switch (type?.value) {
+      case 1: return FallingTub.reader;
+      case 2: return HandFan.reader;
+      default: return null;
+    }
+  }
+}
+
+class Attacker {
+  Attacker._(this._bc, this._bcOffset);
+  factory Attacker(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Attacker> reader = _AttackerReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get swordAttackDamage => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0);
+
+  @override
+  String toString() {
+    return 'Attacker{swordAttackDamage: ${swordAttackDamage}}';
+  }
+
+  AttackerT unpack() => AttackerT(
+      swordAttackDamage: swordAttackDamage);
+
+  static int pack(fb.Builder fbBuilder, AttackerT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class AttackerT implements fb.Packable {
+  int swordAttackDamage;
+
+  AttackerT({
+      this.swordAttackDamage = 0});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, swordAttackDamage);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'AttackerT{swordAttackDamage: ${swordAttackDamage}}';
+  }
+}
+
+class _AttackerReader extends fb.TableReader<Attacker> {
+  const _AttackerReader();
+
+  @override
+  Attacker createObject(fb.BufferContext bc, int offset) => 
+    Attacker._(bc, offset);
+}
+
+class AttackerBuilder {
+  AttackerBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(1);
+  }
+
+  int addSwordAttackDamage(int? swordAttackDamage) {
+    fbBuilder.addInt32(0, swordAttackDamage);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class AttackerObjectBuilder extends fb.ObjectBuilder {
+  final int? _swordAttackDamage;
+
+  AttackerObjectBuilder({
+    int? swordAttackDamage,
+  })
+      : _swordAttackDamage = swordAttackDamage;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, _swordAttackDamage);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class Rapunzel {
+  Rapunzel._(this._bc, this._bcOffset);
+
+  static const fb.Reader<Rapunzel> reader = _RapunzelReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get hairLength => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'Rapunzel{hairLength: ${hairLength}}';
+  }
+
+  RapunzelT unpack() => RapunzelT(
+      hairLength: hairLength);
+
+  static int pack(fb.Builder fbBuilder, RapunzelT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class RapunzelT implements fb.Packable {
+  int hairLength;
+
+  RapunzelT({
+      required this.hairLength});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(hairLength);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'RapunzelT{hairLength: ${hairLength}}';
+  }
+}
+
+class _RapunzelReader extends fb.StructReader<Rapunzel> {
+  const _RapunzelReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  Rapunzel createObject(fb.BufferContext bc, int offset) => 
+    Rapunzel._(bc, offset);
+}
+
+class RapunzelBuilder {
+  RapunzelBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int hairLength) {
+    fbBuilder.putInt32(hairLength);
+    return fbBuilder.offset;
+  }
+
+}
+
+class RapunzelObjectBuilder extends fb.ObjectBuilder {
+  final int _hairLength;
+
+  RapunzelObjectBuilder({
+    required int hairLength,
+  })
+      : _hairLength = hairLength;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_hairLength);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class BookReader {
+  BookReader._(this._bc, this._bcOffset);
+
+  static const fb.Reader<BookReader> reader = _BookReaderReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get booksRead => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'BookReader{booksRead: ${booksRead}}';
+  }
+
+  BookReaderT unpack() => BookReaderT(
+      booksRead: booksRead);
+
+  static int pack(fb.Builder fbBuilder, BookReaderT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class BookReaderT implements fb.Packable {
+  int booksRead;
+
+  BookReaderT({
+      required this.booksRead});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(booksRead);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'BookReaderT{booksRead: ${booksRead}}';
+  }
+}
+
+class _BookReaderReader extends fb.StructReader<BookReader> {
+  const _BookReaderReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  BookReader createObject(fb.BufferContext bc, int offset) => 
+    BookReader._(bc, offset);
+}
+
+class BookReaderBuilder {
+  BookReaderBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int booksRead) {
+    fbBuilder.putInt32(booksRead);
+    return fbBuilder.offset;
+  }
+
+}
+
+class BookReaderObjectBuilder extends fb.ObjectBuilder {
+  final int _booksRead;
+
+  BookReaderObjectBuilder({
+    required int booksRead,
+  })
+      : _booksRead = booksRead;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_booksRead);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class FallingTub {
+  FallingTub._(this._bc, this._bcOffset);
+
+  static const fb.Reader<FallingTub> reader = _FallingTubReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get weight => const fb.Int32Reader().read(_bc, _bcOffset + 0);
+
+  @override
+  String toString() {
+    return 'FallingTub{weight: ${weight}}';
+  }
+
+  FallingTubT unpack() => FallingTubT(
+      weight: weight);
+
+  static int pack(fb.Builder fbBuilder, FallingTubT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class FallingTubT implements fb.Packable {
+  int weight;
+
+  FallingTubT({
+      required this.weight});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(weight);
+    return fbBuilder.offset;
+  }
+
+  @override
+  String toString() {
+    return 'FallingTubT{weight: ${weight}}';
+  }
+}
+
+class _FallingTubReader extends fb.StructReader<FallingTub> {
+  const _FallingTubReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  FallingTub createObject(fb.BufferContext bc, int offset) => 
+    FallingTub._(bc, offset);
+}
+
+class FallingTubBuilder {
+  FallingTubBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  int finish(int weight) {
+    fbBuilder.putInt32(weight);
+    return fbBuilder.offset;
+  }
+
+}
+
+class FallingTubObjectBuilder extends fb.ObjectBuilder {
+  final int _weight;
+
+  FallingTubObjectBuilder({
+    required int weight,
+  })
+      : _weight = weight;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.putInt32(_weight);
+    return fbBuilder.offset;
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class HandFan {
+  HandFan._(this._bc, this._bcOffset);
+  factory HandFan(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<HandFan> reader = _HandFanReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  int get length => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0);
+
+  @override
+  String toString() {
+    return 'HandFan{length: ${length}}';
+  }
+
+  HandFanT unpack() => HandFanT(
+      length: length);
+
+  static int pack(fb.Builder fbBuilder, HandFanT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class HandFanT implements fb.Packable {
+  int length;
+
+  HandFanT({
+      this.length = 0});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, length);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'HandFanT{length: ${length}}';
+  }
+}
+
+class _HandFanReader extends fb.TableReader<HandFan> {
+  const _HandFanReader();
+
+  @override
+  HandFan createObject(fb.BufferContext bc, int offset) => 
+    HandFan._(bc, offset);
+}
+
+class HandFanBuilder {
+  HandFanBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(1);
+  }
+
+  int addLength(int? length) {
+    fbBuilder.addInt32(0, length);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class HandFanObjectBuilder extends fb.ObjectBuilder {
+  final int? _length;
+
+  HandFanObjectBuilder({
+    int? length,
+  })
+      : _length = length;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(1);
+    fbBuilder.addInt32(0, _length);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}
+class Movie {
+  Movie._(this._bc, this._bcOffset);
+  factory Movie(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<Movie> reader = _MovieReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  CharacterTypeId? get mainCharacterType => CharacterTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 4));
+  dynamic get mainCharacter => _CharacterReader(mainCharacterType).vTableGetNullable(_bc, _bcOffset, 6);
+  List<CharacterTypeId>? get charactersType => const fb.ListReader<CharacterTypeId>(CharacterTypeId.reader).vTableGetNullable(_bc, _bcOffset, 8);
+  List<dynamic>? get characters => fb.UnionListReader((index) => _CharacterReader(charactersType?[index])).vTableGetNullable(_bc, _bcOffset, 10);
+
+  @override
+  String toString() {
+    return 'Movie{mainCharacterType: ${mainCharacterType}, mainCharacter: ${mainCharacter}, charactersType: ${charactersType}, characters: ${characters}}';
+  }
+
+  MovieT unpack() => MovieT(
+      mainCharacterType: mainCharacterType,
+      mainCharacter: mainCharacter is String ? mainCharacter : mainCharacter?.unpack(),
+      charactersType: charactersType?.toList(),
+      characters: characters?.map((e) => e is String ? e : e.unpack()).toList());
+
+  static int pack(fb.Builder fbBuilder, MovieT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class MovieT implements fb.Packable {
+  CharacterTypeId? mainCharacterType;
+  dynamic mainCharacter;
+  List<CharacterTypeId>? charactersType;
+  List<dynamic>? characters;
+
+  MovieT({
+      this.mainCharacterType,
+      this.mainCharacter,
+      this.charactersType,
+      this.characters});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    final int? mainCharacterOffset = mainCharacter is String ? fbBuilder.writeString(mainCharacter) : mainCharacter?.pack(fbBuilder);
+    final int? charactersTypeOffset = charactersType == null ? null
+        : fbBuilder.writeListUint8(charactersType!.map((f) => f.value).toList());
+    final int? charactersOffset = characters == null ? null
+        : fbBuilder.writeList(characters!.map<int>((u) => u is String ? fbBuilder.writeString(u) : u.pack(fbBuilder)).toList());
+    fbBuilder.startTable(4);
+    fbBuilder.addUint8(0, mainCharacterType?.value);
+    fbBuilder.addOffset(1, mainCharacterOffset);
+    fbBuilder.addOffset(2, charactersTypeOffset);
+    fbBuilder.addOffset(3, charactersOffset);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'MovieT{mainCharacterType: ${mainCharacterType}, mainCharacter: ${mainCharacter}, charactersType: ${charactersType}, characters: ${characters}}';
+  }
+}
+
+class _MovieReader extends fb.TableReader<Movie> {
+  const _MovieReader();
+
+  @override
+  Movie createObject(fb.BufferContext bc, int offset) => 
+    Movie._(bc, offset);
+}
+
+class MovieBuilder {
+  MovieBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(4);
+  }
+
+  int addMainCharacterType(CharacterTypeId? mainCharacterType) {
+    fbBuilder.addUint8(0, mainCharacterType?.value);
+    return fbBuilder.offset;
+  }
+  int addMainCharacterOffset(int? offset) {
+    fbBuilder.addOffset(1, offset);
+    return fbBuilder.offset;
+  }
+  int addCharactersTypeOffset(int? offset) {
+    fbBuilder.addOffset(2, offset);
+    return fbBuilder.offset;
+  }
+  int addCharactersOffset(int? offset) {
+    fbBuilder.addOffset(3, offset);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class MovieObjectBuilder extends fb.ObjectBuilder {
+  final CharacterTypeId? _mainCharacterType;
+  final dynamic _mainCharacter;
+  final List<CharacterTypeId>? _charactersType;
+  final List<dynamic>? _characters;
+
+  MovieObjectBuilder({
+    CharacterTypeId? mainCharacterType,
+    dynamic mainCharacter,
+    List<CharacterTypeId>? charactersType,
+    List<dynamic>? characters,
+  })
+      : _mainCharacterType = mainCharacterType,
+        _mainCharacter = mainCharacter,
+        _charactersType = charactersType,
+        _characters = characters;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    final int? mainCharacterOffset = _mainCharacter is String ? fbBuilder.writeString(_mainCharacter) : _mainCharacter?.getOrCreateOffset(fbBuilder);
+    final int? charactersTypeOffset = _charactersType == null ? null
+        : fbBuilder.writeListUint8(_charactersType!.map((f) => f.value).toList());
+    final int? charactersOffset = _characters == null ? null
+        : fbBuilder.writeList(_characters!.map<int>((u) => u is String ? fbBuilder.writeString(u) : u.getOrCreateOffset(fbBuilder)).toList());
+    fbBuilder.startTable(4);
+    fbBuilder.addUint8(0, _mainCharacterType?.value);
+    fbBuilder.addOffset(1, mainCharacterOffset);
+    fbBuilder.addOffset(2, charactersTypeOffset);
+    fbBuilder.addOffset(3, charactersOffset);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}