diff --git a/tests/cpp17/generated_cpp17/union_vector_generated.h b/tests/cpp17/generated_cpp17/union_vector_generated.h
index e73bb1a8f..e2274b961 100644
--- a/tests/cpp17/generated_cpp17/union_vector_generated.h
+++ b/tests/cpp17/generated_cpp17/union_vector_generated.h
@@ -556,6 +556,7 @@ struct MovieT : public ::flatbuffers::NativeTable {
   typedef Movie TableType;
   CharacterUnion main_character{};
   std::vector<CharacterUnion> characters{};
+  GadgetUnion gadget{};
 };
 
 struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -569,7 +570,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     VT_MAIN_CHARACTER_TYPE = 4,
     VT_MAIN_CHARACTER = 6,
     VT_CHARACTERS_TYPE = 8,
-    VT_CHARACTERS = 10
+    VT_CHARACTERS = 10,
+    VT_GADGET_TYPE = 12,
+    VT_GADGET = 14
   };
   Character main_character_type() const {
     return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
@@ -628,12 +631,37 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   }
+  Gadget gadget_type() const {
+    return static_cast<Gadget>(GetField<uint8_t>(VT_GADGET_TYPE, 0));
+  }
+  const void *gadget() const {
+    return GetPointer<const void *>(VT_GADGET);
+  }
+  template<typename T> const T *gadget_as() const;
+  const FallingTub *gadget_as_FallingTub() const {
+    return gadget_type() == Gadget::FallingTub ? static_cast<const FallingTub *>(gadget()) : nullptr;
+  }
+  const HandFan *gadget_as_HandFan() const {
+    return gadget_type() == Gadget::HandFan ? static_cast<const HandFan *>(gadget()) : nullptr;
+  }
+  void *mutable_gadget() {
+    return GetPointer<void *>(VT_GADGET);
+  }
+  template<typename T> T *mutable_gadget_as();
+  FallingTub *mutable_gadget_as_FallingTub() {
+    return gadget_type() == Gadget::FallingTub ? static_cast<FallingTub *>(mutable_gadget()) : nullptr;
+  }
+  HandFan *mutable_gadget_as_HandFan() {
+    return gadget_type() == Gadget::HandFan ? static_cast<HandFan *>(mutable_gadget()) : nullptr;
+  }
   template<size_t Index>
   auto get_field() const {
          if constexpr (Index == 0) return main_character_type();
     else if constexpr (Index == 1) return main_character();
     else if constexpr (Index == 2) return characters_type();
     else if constexpr (Index == 3) return characters();
+    else if constexpr (Index == 4) return gadget_type();
+    else if constexpr (Index == 5) return gadget();
     else static_assert(Index != -1, "Invalid Field Index");
   }
   template <bool B = false>
@@ -647,6 +675,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyOffset(verifier, VT_CHARACTERS) &&
            verifier.VerifyVector(characters()) &&
            VerifyCharacterVector(verifier, characters(), characters_type()) &&
+           VerifyField<uint8_t>(verifier, VT_GADGET_TYPE, 1) &&
+           VerifyOffset(verifier, VT_GADGET) &&
+           VerifyGadget(verifier, gadget(), gadget_type()) &&
            verifier.EndTable();
   }
   MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -654,6 +685,22 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
 };
 
+template<> inline const FallingTub *Movie::gadget_as<FallingTub>() const {
+  return gadget_as_FallingTub();
+}
+
+template<> inline FallingTub *Movie::mutable_gadget_as<FallingTub>() {
+  return mutable_gadget_as_FallingTub();
+}
+
+template<> inline const HandFan *Movie::gadget_as<HandFan>() const {
+  return gadget_as_HandFan();
+}
+
+template<> inline HandFan *Movie::mutable_gadget_as<HandFan>() {
+  return mutable_gadget_as_HandFan();
+}
+
 struct MovieBuilder {
   typedef Movie Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -670,6 +717,12 @@ struct MovieBuilder {
   void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
     fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
   }
+  void add_gadget_type(Gadget gadget_type) {
+    fbb_.AddElement<uint8_t>(Movie::VT_GADGET_TYPE, static_cast<uint8_t>(gadget_type), 0);
+  }
+  void add_gadget(::flatbuffers::Offset<void> gadget) {
+    fbb_.AddOffset(Movie::VT_GADGET, gadget);
+  }
   explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -686,11 +739,15 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(
     Character main_character_type = Character::NONE,
     ::flatbuffers::Offset<void> main_character = 0,
     ::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0,
+    Gadget gadget_type = Gadget::NONE,
+    ::flatbuffers::Offset<void> gadget = 0) {
   MovieBuilder builder_(_fbb);
+  builder_.add_gadget(gadget);
   builder_.add_characters(characters);
   builder_.add_characters_type(characters_type);
   builder_.add_main_character(main_character);
+  builder_.add_gadget_type(gadget_type);
   builder_.add_main_character_type(main_character_type);
   return builder_.Finish();
 }
@@ -700,12 +757,14 @@ struct Movie::Traits {
   static auto constexpr Create = CreateMovie;
   static constexpr auto name = "Movie";
   static constexpr auto fully_qualified_name = "Movie";
-  static constexpr size_t fields_number = 4;
+  static constexpr size_t fields_number = 6;
   static constexpr std::array<const char *, fields_number> field_names = {
     "main_character_type",
     "main_character",
     "characters_type",
-    "characters"
+    "characters",
+    "gadget_type",
+    "gadget"
   };
   template<size_t Index>
   using FieldType = decltype(std::declval<type>().get_field<Index>());
@@ -716,7 +775,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
     Character main_character_type = Character::NONE,
     ::flatbuffers::Offset<void> main_character = 0,
     const std::vector<Character> *characters_type = nullptr,
-    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
+    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr,
+    Gadget gadget_type = Gadget::NONE,
+    ::flatbuffers::Offset<void> gadget = 0) {
   auto characters_type__ = characters_type ? _fbb.CreateVector<Character>(*characters_type) : 0;
   auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
   return CreateMovie(
@@ -724,7 +785,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
       main_character_type,
       main_character,
       characters_type__,
-      characters__);
+      characters__,
+      gadget_type,
+      gadget);
 }
 
 ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -794,6 +857,8 @@ inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t
   { auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
   { auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
   { auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
+  { auto _e = gadget_type(); _o->gadget.type = _e; }
+  { auto _e = gadget(); if (_e) _o->gadget.value = GadgetUnion::UnPack(_e, gadget_type(), _resolver); }
 }
 
 inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -808,12 +873,16 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
   auto _main_character = _o->main_character.Pack(_fbb);
   auto _characters_type = _o->characters.size() ? _fbb.CreateVector<Character>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].type; }, &_va) : 0;
   auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
+  auto _gadget_type = _o->gadget.type;
+  auto _gadget = _o->gadget.Pack(_fbb);
   return CreateMovie(
       _fbb,
       _main_character_type,
       _main_character,
       _characters_type,
-      _characters);
+      _characters,
+      _gadget_type,
+      _gadget);
 }
 
 template <bool B>
@@ -1208,19 +1277,24 @@ inline const ::flatbuffers::TypeTable *MovieTypeTable() {
     { ::flatbuffers::ET_UTYPE, 0, 0 },
     { ::flatbuffers::ET_SEQUENCE, 0, 0 },
     { ::flatbuffers::ET_UTYPE, 1, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 0 }
+    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
+    { ::flatbuffers::ET_UTYPE, 0, 1 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 1 }
   };
   static const ::flatbuffers::TypeFunction type_refs[] = {
-    CharacterTypeTable
+    CharacterTypeTable,
+    GadgetTypeTable
   };
   static const char * const names[] = {
     "main_character_type",
     "main_character",
     "characters_type",
-    "characters"
+    "characters",
+    "gadget_type",
+    "gadget"
   };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
+    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }
diff --git a/tests/cpp17/test_cpp17.cpp b/tests/cpp17/test_cpp17.cpp
index 6c1929120..485e948c1 100644
--- a/tests/cpp17/test_cpp17.cpp
+++ b/tests/cpp17/test_cpp17.cpp
@@ -255,10 +255,60 @@ void OptionalScalarsTest() {
   TEST_ASSERT(opts->maybe_i32() == std::optional<int64_t>(-1));
 }
 
+void MutableUnionMembersTest() {
+  flatbuffers::FlatBufferBuilder fbb;
+
+  // Create a Movie with union members
+  auto other_str = fbb.CreateString("other_character");
+  auto attacker = cpp17::CreateAttacker(fbb, 100);
+
+  std::vector<flatbuffers::Offset<void>> characters_vec;
+  std::vector<cpp17::Character> character_types;
+
+  characters_vec.push_back(attacker.Union());
+  character_types.push_back(cpp17::Character::MuLan);
+
+  characters_vec.push_back(other_str.Union());
+  character_types.push_back(cpp17::Character::Other);
+
+  auto characters_vector = fbb.CreateVector(characters_vec);
+  auto character_types_vector = fbb.CreateVector(character_types);
+
+  auto hand_fan = cpp17::CreateHandFan(fbb, 55);
+
+  auto movie = cpp17::CreateMovie(
+      fbb, cpp17::Character::MuLan, attacker.Union(), character_types_vector,
+      characters_vector, cpp17::Gadget::HandFan, hand_fan.Union());
+  fbb.Finish(movie);
+
+  // Test mutable union accessors
+  auto mutable_movie = cpp17::GetMutableMovie(fbb.GetBufferPointer());
+
+  // Test main_character union
+  TEST_EQ(mutable_movie->main_character_type(), cpp17::Character::MuLan);
+  auto main_attacker = mutable_movie->mutable_main_character_as_MuLan();
+  TEST_ASSERT(main_attacker != nullptr);
+  TEST_EQ(main_attacker->sword_attack_damage(), 100);
+  TEST_ASSERT(main_attacker->mutate_sword_attack_damage(150));
+  TEST_EQ(main_attacker->sword_attack_damage(), 150);
+
+  TEST_EQ(mutable_movie->gadget_as<cpp17::HandFan>()->length(), 55);
+  mutable_movie->mutable_gadget_as<cpp17::HandFan>()->mutate_length(75);
+  TEST_EQ(mutable_movie->gadget_as<cpp17::HandFan>()->length(), 75);
+
+  TEST_ASSERT(mutable_movie->mutable_gadget_as<cpp17::FallingTub>() == nullptr);
+
+  // Test characters vector unions
+  TEST_EQ(mutable_movie->characters_type()->size(), 2);
+  TEST_EQ(mutable_movie->characters_type()->Get(0), cpp17::Character::MuLan);
+  TEST_EQ(mutable_movie->characters_type()->Get(1), cpp17::Character::Other);
+}
+
 int FlatBufferCpp17Tests() {
   CreateTableByTypeTest();
   OptionalScalarsTest();
   StringifyAnyFlatbuffersTypeTest();
+  MutableUnionMembersTest();
   return 0;
 }
 }  // namespace
diff --git a/tests/swift/Tests/Flatbuffers/union_vector_generated.swift b/tests/swift/Tests/Flatbuffers/union_vector_generated.swift
index 59d78793b..8800af077 100644
--- a/tests/swift/Tests/Flatbuffers/union_vector_generated.swift
+++ b/tests/swift/Tests/Flatbuffers/union_vector_generated.swift
@@ -496,6 +496,8 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
     case mainCharacter = 6
     case charactersType = 8
     case characters = 10
+    case gadgetType = 12
+    case gadget = 14
     var v: Int32 { Int32(self.rawValue) }
     var p: VOffset { self.rawValue }
   }
@@ -505,24 +507,32 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
   public var charactersType: FlatbufferVector<Character> { return _accessor.vector(at: VTOFFSET.charactersType.v, byteSize: 1) }
   public var characters: UnionFlatbufferVector { return _accessor.unionVector(at: VTOFFSET.characters.v, byteSize: 4) }
   public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
-  public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
+  public var gadgetType: Gadget { let o = _accessor.offset(VTOFFSET.gadgetType.v); return o == 0 ? .none_ : Gadget(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+  public func gadget<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.gadget.v); return o == 0 ? nil : _accessor.union(o) }
+  public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) }
   public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
   public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
   public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
   public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
+  public static func add(gadgetType: Gadget, _ fbb: inout FlatBufferBuilder) { fbb.add(element: gadgetType.rawValue, def: 0, at: VTOFFSET.gadgetType.p) }
+  public static func add(gadget: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: gadget, at: VTOFFSET.gadget.p) }
   public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createMovie(
     _ fbb: inout FlatBufferBuilder,
     mainCharacterType: Character = .none_,
     mainCharacterOffset mainCharacter: Offset = Offset(),
     charactersTypeVectorOffset charactersType: Offset = Offset(),
-    charactersVectorOffset characters: Offset = Offset()
+    charactersVectorOffset characters: Offset = Offset(),
+    gadgetType: Gadget = .none_,
+    gadgetOffset gadget: Offset = Offset()
   ) -> Offset {
     let __start = Movie.startMovie(&fbb)
     Movie.add(mainCharacterType: mainCharacterType, &fbb)
     Movie.add(mainCharacter: mainCharacter, &fbb)
     Movie.addVectorOf(charactersType: charactersType, &fbb)
     Movie.addVectorOf(characters: characters, &fbb)
+    Movie.add(gadgetType: gadgetType, &fbb)
+    Movie.add(gadget: gadget, &fbb)
     return Movie.endMovie(&fbb, start: __start)
   }
 
@@ -543,6 +553,7 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
     }
     let __characters = builder.createVector(ofOffsets: __characters__)
     let __charactersType = builder.createVector(obj.characters.compactMap { $0?.type })
+    let __gadget = obj.gadget?.pack(builder: &builder) ?? Offset()
     let __root = Movie.startMovie(&builder)
     if let o = obj.mainCharacter?.type {
       Movie.add(mainCharacterType: o, &builder)
@@ -551,6 +562,11 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
 
     Movie.addVectorOf(charactersType: __charactersType, &builder)
     Movie.addVectorOf(characters: __characters, &builder)
+    if let o = obj.gadget?.type {
+      Movie.add(gadgetType: o, &builder)
+      Movie.add(gadget: __gadget, &builder)
+    }
+
     return Movie.endMovie(&builder, start: __root)
   }
 
@@ -592,6 +608,16 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
         try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
       }
     })
+    try _v.visit(unionKey: VTOFFSET.gadgetType.p, unionField: VTOFFSET.gadget.p, unionKeyName: "gadgetType", fieldName: "gadget", required: false, completion: { (verifier, key: Gadget, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .fallingtub:
+        try FallingTub.verify(&verifier, at: pos, of: FallingTub.self)
+      case .handfan:
+        try ForwardOffset<HandFan>.verify(&verifier, at: pos, of: HandFan.self)
+      }
+    })
     _v.finish()
   }
 }
@@ -603,6 +629,8 @@ extension Movie: Encodable {
     case mainCharacter = "main_character"
     case charactersType = "characters_type"
     case characters = "characters"
+    case gadgetType = "gadget_type"
+    case gadget = "gadget"
   }
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -656,6 +684,18 @@ extension Movie: Encodable {
       default: break;
       }
     }
+    if gadgetType != .none_ {
+      try container.encodeIfPresent(gadgetType, forKey: .gadgetType)
+    }
+    switch gadgetType {
+    case .fallingtub:
+      let _v = gadget(type: FallingTub.self)
+      try container.encodeIfPresent(_v, forKey: .gadget)
+    case .handfan:
+      let _v = gadget(type: HandFan.self)
+      try container.encodeIfPresent(_v, forKey: .gadget)
+    default: break;
+    }
   }
 }
 
@@ -663,6 +703,7 @@ public class MovieT: NativeObject {
 
   public var mainCharacter: CharacterUnion?
   public var characters: [CharacterUnion?]
+  public var gadget: GadgetUnion?
 
   public init(_ _t: borrowing Movie) {
     switch _t.mainCharacterType {
@@ -711,6 +752,15 @@ public class MovieT: NativeObject {
         default: break
         }
     }
+    switch _t.gadgetType {
+    case .fallingtub:
+      let _v = _t.gadget(type: FallingTub_Mutable.self)
+      gadget = GadgetUnion(_v?.unpack(), type: .fallingtub)
+    case .handfan:
+      let _v = _t.gadget(type: HandFan.self)
+      gadget = GadgetUnion(_v?.unpack(), type: .handfan)
+    default: break
+    }
   }
 
   public init() {
diff --git a/tests/ts/union_vector/movie.ts b/tests/ts/union_vector/movie.ts
index 2c6235e20..c7559463f 100644
--- a/tests/ts/union_vector/movie.ts
+++ b/tests/ts/union_vector/movie.ts
@@ -7,6 +7,9 @@ import * as flatbuffers from 'flatbuffers';
 import { Attacker, AttackerT } from './attacker.js';
 import { BookReader, BookReaderT } from './book-reader.js';
 import { Character, unionToCharacter, unionListToCharacter } from './character.js';
+import { FallingTub, FallingTubT } from './falling-tub.js';
+import { Gadget, unionToGadget, unionListToGadget } from './gadget.js';
+import { HandFan, HandFanT } from './hand-fan.js';
 import { Rapunzel, RapunzelT } from './rapunzel.js';
 
 
@@ -67,12 +70,22 @@ charactersLength():number {
   return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
 }
 
+gadgetType():Gadget {
+  const offset = this.bb!.__offset(this.bb_pos, 12);
+  return offset ? this.bb!.readUint8(this.bb_pos + offset) : Gadget.NONE;
+}
+
+gadget<T extends flatbuffers.Table>(obj:any):any|null {
+  const offset = this.bb!.__offset(this.bb_pos, 14);
+  return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;
+}
+
 static getFullyQualifiedName(): "Movie" {
   return 'Movie';
 }
 
 static startMovie(builder:flatbuffers.Builder) {
-  builder.startObject(4);
+  builder.startObject(6);
 }
 
 static addMainCharacterType(builder:flatbuffers.Builder, mainCharacterType:Character) {
@@ -115,6 +128,14 @@ static startCharactersVector(builder:flatbuffers.Builder, numElems:number) {
   builder.startVector(4, numElems, 4);
 }
 
+static addGadgetType(builder:flatbuffers.Builder, gadgetType:Gadget) {
+  builder.addFieldInt8(4, gadgetType, Gadget.NONE);
+}
+
+static addGadget(builder:flatbuffers.Builder, gadgetOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(5, gadgetOffset, 0);
+}
+
 static endMovie(builder:flatbuffers.Builder):flatbuffers.Offset {
   const offset = builder.endObject();
   return offset;
@@ -128,12 +149,14 @@ static finishSizePrefixedMovieBuffer(builder:flatbuffers.Builder, offset:flatbuf
   builder.finish(offset, 'MOVI', true);
 }
 
-static createMovie(builder:flatbuffers.Builder, mainCharacterType:Character, mainCharacterOffset:flatbuffers.Offset, charactersTypeOffset:flatbuffers.Offset, charactersOffset:flatbuffers.Offset):flatbuffers.Offset {
+static createMovie(builder:flatbuffers.Builder, mainCharacterType:Character, mainCharacterOffset:flatbuffers.Offset, charactersTypeOffset:flatbuffers.Offset, charactersOffset:flatbuffers.Offset, gadgetType:Gadget, gadgetOffset:flatbuffers.Offset):flatbuffers.Offset {
   Movie.startMovie(builder);
   Movie.addMainCharacterType(builder, mainCharacterType);
   Movie.addMainCharacter(builder, mainCharacterOffset);
   Movie.addCharactersType(builder, charactersTypeOffset);
   Movie.addCharacters(builder, charactersOffset);
+  Movie.addGadgetType(builder, gadgetType);
+  Movie.addGadget(builder, gadgetOffset);
   return Movie.endMovie(builder);
 }
 
@@ -159,6 +182,12 @@ unpack(): MovieT {
       ret.push(temp.unpack());
     }
     return ret;
+  })(),
+    this.gadgetType(),
+    (() => {
+      const temp = unionToGadget(this.gadgetType(), this.gadget.bind(this));
+      if(temp === null) { return null; }
+      return temp.unpack()
   })()
   );
 }
@@ -186,6 +215,12 @@ unpackTo(_o: MovieT): void {
     }
     return ret;
   })();
+  _o.gadgetType = this.gadgetType();
+  _o.gadget = (() => {
+      const temp = unionToGadget(this.gadgetType(), this.gadget.bind(this));
+      if(temp === null) { return null; }
+      return temp.unpack()
+  })();
 }
 }
 
@@ -194,7 +229,9 @@ constructor(
   public mainCharacterType: Character = Character.NONE,
   public mainCharacter: AttackerT|BookReaderT|RapunzelT|string|null = null,
   public charactersType: (Character)[] = [],
-  public characters: (AttackerT|BookReaderT|RapunzelT|string)[] = []
+  public characters: (AttackerT|BookReaderT|RapunzelT|string)[] = [],
+  public gadgetType: Gadget = Gadget.NONE,
+  public gadget: FallingTubT|HandFanT|null = null
 ){}
 
 
@@ -202,12 +239,15 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
   const mainCharacter = builder.createObjectOffset(this.mainCharacter);
   const charactersType = Movie.createCharactersTypeVector(builder, this.charactersType);
   const characters = Movie.createCharactersVector(builder, builder.createObjectOffsetList(this.characters));
+  const gadget = builder.createObjectOffset(this.gadget);
 
   return Movie.createMovie(builder,
     this.mainCharacterType,
     mainCharacter,
     charactersType,
-    characters
+    characters,
+    this.gadgetType,
+    gadget
   );
 }
 }
diff --git a/tests/union_vector/Movie.cs b/tests/union_vector/Movie.cs
index 6176c8bd9..d97513571 100644
--- a/tests/union_vector/Movie.cs
+++ b/tests/union_vector/Movie.cs
@@ -38,21 +38,29 @@ public struct Movie : IFlatbufferObject
   public TTable? Characters<TTable>(int j) where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(__p.__vector(o) + j * 4) : null; }
   public string CharactersAsString(int j) { int o = __p.__offset(10); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
   public int CharactersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public Gadget GadgetType { get { int o = __p.__offset(12); return o != 0 ? (Gadget)__p.bb.Get(o + __p.bb_pos) : Gadget.NONE; } }
+  public TTable? Gadget<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(14); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public FallingTub GadgetAsFallingTub() { return Gadget<FallingTub>().Value; }
+  public HandFan GadgetAsHandFan() { return Gadget<HandFan>().Value; }
 
   public static Offset<Movie> CreateMovie(FlatBufferBuilder builder,
       Character main_character_type = Character.NONE,
       int main_characterOffset = 0,
       VectorOffset characters_typeOffset = default(VectorOffset),
-      VectorOffset charactersOffset = default(VectorOffset)) {
-    builder.StartTable(4);
+      VectorOffset charactersOffset = default(VectorOffset),
+      Gadget gadget_type = Gadget.NONE,
+      int gadgetOffset = 0) {
+    builder.StartTable(6);
+    Movie.AddGadget(builder, gadgetOffset);
     Movie.AddCharacters(builder, charactersOffset);
     Movie.AddCharactersType(builder, characters_typeOffset);
     Movie.AddMainCharacter(builder, main_characterOffset);
+    Movie.AddGadgetType(builder, gadget_type);
     Movie.AddMainCharacterType(builder, main_character_type);
     return Movie.EndMovie(builder);
   }
 
-  public static void StartMovie(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void StartMovie(FlatBufferBuilder builder) { builder.StartTable(6); }
   public static void AddMainCharacterType(FlatBufferBuilder builder, Character mainCharacterType) { builder.AddByte(0, (byte)mainCharacterType, 0); }
   public static void AddMainCharacter(FlatBufferBuilder builder, int mainCharacterOffset) { builder.AddOffset(1, mainCharacterOffset, 0); }
   public static void AddCharactersType(FlatBufferBuilder builder, VectorOffset charactersTypeOffset) { builder.AddOffset(2, charactersTypeOffset.Value, 0); }
@@ -67,6 +75,8 @@ public struct Movie : IFlatbufferObject
   public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCharactersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddGadgetType(FlatBufferBuilder builder, Gadget gadgetType) { builder.AddByte(4, (byte)gadgetType, 0); }
+  public static void AddGadget(FlatBufferBuilder builder, int gadgetOffset) { builder.AddOffset(5, gadgetOffset, 0); }
   public static Offset<Movie> EndMovie(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<Movie>(o);
@@ -129,6 +139,17 @@ public struct Movie : IFlatbufferObject
       }
       _o.Characters.Add(_o_Characters);
     }
+    _o.Gadget = new GadgetUnion();
+    _o.Gadget.Type = this.GadgetType;
+    switch (this.GadgetType) {
+      default: break;
+      case Gadget.FallingTub:
+        _o.Gadget.Value = this.Gadget<FallingTub>().HasValue ? this.Gadget<FallingTub>().Value.UnPack() : null;
+        break;
+      case Gadget.HandFan:
+        _o.Gadget.Value = this.Gadget<HandFan>().HasValue ? this.Gadget<HandFan>().Value.UnPack() : null;
+        break;
+    }
   }
   public static Offset<Movie> Pack(FlatBufferBuilder builder, MovieT _o) {
     if (_o == null) return default(Offset<Movie>);
@@ -146,12 +167,16 @@ public struct Movie : IFlatbufferObject
       for (var _j = 0; _j < __characters.Length; ++_j) { __characters[_j] = CharacterUnion.Pack(builder,  _o.Characters[_j]); }
       _characters = CreateCharactersVector(builder, __characters);
     }
+    var _gadget_type = _o.Gadget == null ? Gadget.NONE : _o.Gadget.Type;
+    var _gadget = _o.Gadget == null ? 0 : GadgetUnion.Pack(builder, _o.Gadget);
     return CreateMovie(
       builder,
       _main_character_type,
       _main_character,
       _characters_type,
-      _characters);
+      _characters,
+      _gadget_type,
+      _gadget);
   }
 }
 
@@ -190,10 +215,24 @@ public class MovieT
   [Newtonsoft.Json.JsonProperty("characters")]
   [Newtonsoft.Json.JsonConverter(typeof(CharacterUnion_JsonConverter))]
   public List<CharacterUnion> Characters { get; set; }
+  [Newtonsoft.Json.JsonProperty("gadget_type")]
+  private Gadget GadgetType {
+    get {
+      return this.Gadget != null ? this.Gadget.Type : Gadget.NONE;
+    }
+    set {
+      this.Gadget = new GadgetUnion();
+      this.Gadget.Type = value;
+    }
+  }
+  [Newtonsoft.Json.JsonProperty("gadget")]
+  [Newtonsoft.Json.JsonConverter(typeof(GadgetUnion_JsonConverter))]
+  public GadgetUnion Gadget { get; set; }
 
   public MovieT() {
     this.MainCharacter = null;
     this.Characters = null;
+    this.Gadget = null;
   }
 
   public static MovieT DeserializeFromJson(string jsonText) {
@@ -221,6 +260,8 @@ static public class MovieVerify
       && verifier.VerifyField(tablePos, 4 /*MainCharacterType*/, 1 /*Character*/, 1, false)
       && verifier.VerifyUnion(tablePos, 4, 6 /*MainCharacter*/, CharacterVerify.Verify, false)
       && verifier.VerifyVectorOfData(tablePos, 8 /*CharactersType*/, 1 /*Character*/, false)
+      && verifier.VerifyField(tablePos, 12 /*GadgetType*/, 1 /*Gadget*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 12, 14 /*Gadget*/, GadgetVerify.Verify, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }
diff --git a/tests/union_vector/Movie.java b/tests/union_vector/Movie.java
index 8cdcdc1be..d81d771c8 100644
--- a/tests/union_vector/Movie.java
+++ b/tests/union_vector/Movie.java
@@ -37,21 +37,27 @@ public final class Movie extends com.google.flatbuffers.Table {
   public int charactersLength() { int o = __offset(10); return o != 0 ? __vector_len(o) : 0; }
   public UnionVector charactersVector() { return charactersVector(new UnionVector()); }
   public UnionVector charactersVector(UnionVector obj) { int o = __offset(10); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  public byte gadgetType() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) : 0; }
+  public com.google.flatbuffers.Table gadget(com.google.flatbuffers.Table obj) { int o = __offset(14); return o != 0 ? __union(obj, o + bb_pos) : null; }
 
   public static int createMovie(FlatBufferBuilder builder,
       byte mainCharacterType,
       int mainCharacterOffset,
       int charactersTypeOffset,
-      int charactersOffset) {
-    builder.startTable(4);
+      int charactersOffset,
+      byte gadgetType,
+      int gadgetOffset) {
+    builder.startTable(6);
+    Movie.addGadget(builder, gadgetOffset);
     Movie.addCharacters(builder, charactersOffset);
     Movie.addCharactersType(builder, charactersTypeOffset);
     Movie.addMainCharacter(builder, mainCharacterOffset);
+    Movie.addGadgetType(builder, gadgetType);
     Movie.addMainCharacterType(builder, mainCharacterType);
     return Movie.endMovie(builder);
   }
 
-  public static void startMovie(FlatBufferBuilder builder) { builder.startTable(4); }
+  public static void startMovie(FlatBufferBuilder builder) { builder.startTable(6); }
   public static void addMainCharacterType(FlatBufferBuilder builder, byte mainCharacterType) { builder.addByte(0, mainCharacterType, 0); }
   public static void addMainCharacter(FlatBufferBuilder builder, int mainCharacterOffset) { builder.addOffset(1, mainCharacterOffset, 0); }
   public static void addCharactersType(FlatBufferBuilder builder, int charactersTypeOffset) { builder.addOffset(2, charactersTypeOffset, 0); }
@@ -60,6 +66,8 @@ public final class Movie extends com.google.flatbuffers.Table {
   public static void addCharacters(FlatBufferBuilder builder, int charactersOffset) { builder.addOffset(3, charactersOffset, 0); }
   public static int createCharactersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
   public static void startCharactersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addGadgetType(FlatBufferBuilder builder, byte gadgetType) { builder.addByte(4, gadgetType, 0); }
+  public static void addGadget(FlatBufferBuilder builder, int gadgetOffset) { builder.addOffset(5, gadgetOffset, 0); }
   public static int endMovie(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -107,6 +115,18 @@ public final class Movie extends com.google.flatbuffers.Table {
       _oCharacters[_j] = _oCharactersElement;
     }
     _o.setCharacters(_oCharacters);
+    GadgetUnion _oGadget = new GadgetUnion();
+    byte _oGadgetType = gadgetType();
+    _oGadget.setType(_oGadgetType);
+    com.google.flatbuffers.Table _oGadgetValue;
+    switch (_oGadgetType) {
+      case Gadget.HandFan:
+        _oGadgetValue = gadget(new HandFan());
+        _oGadget.setValue(_oGadgetValue != null ? ((HandFan) _oGadgetValue).unpack() : null);
+        break;
+      default: break;
+    }
+    _o.setGadget(_oGadget);
   }
   public static int pack(FlatBufferBuilder builder, MovieT _o) {
     if (_o == null) return 0;
@@ -126,12 +146,16 @@ public final class Movie extends com.google.flatbuffers.Table {
       for (CharacterUnion _e : _o.getCharacters()) { __characters[_j] = CharacterUnion.pack(builder,  _o.getCharacters()[_j]); _j++;}
       _characters = createCharactersVector(builder, __characters);
     }
+    byte _gadgetType = _o.getGadget() == null ? Gadget.NONE : _o.getGadget().getType();
+    int _gadget = _o.getGadget() == null ? 0 : GadgetUnion.pack(builder, _o.getGadget());
     return createMovie(
       builder,
       _mainCharacterType,
       _mainCharacter,
       _charactersType,
-      _characters);
+      _characters,
+      _gadgetType,
+      _gadget);
   }
 }
 
diff --git a/tests/union_vector/Movie.kt b/tests/union_vector/Movie.kt
index 0e8645d5a..1a3786613 100644
--- a/tests/union_vector/Movie.kt
+++ b/tests/union_vector/Movie.kt
@@ -78,6 +78,23 @@ class Movie : Table() {
         get() {
             val o = __offset(10); return if (o != 0) __vector_len(o) else 0
         }
+    val gadgetType : UByte
+        get() {
+            val o = __offset(12)
+            return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
+        }
+    fun mutateGadgetType(gadgetType: UByte) : Boolean {
+        val o = __offset(12)
+        return if (o != 0) {
+            bb.put(o + bb_pos, gadgetType.toByte())
+            true
+        } else {
+            false
+        }
+    }
+    fun gadget(obj: Table) : Table? {
+        val o = __offset(14); return if (o != 0) __union(obj, o + bb_pos) else null
+    }
     companion object {
         fun validateVersion() = Constants.FLATBUFFERS_25_9_23()
         fun getRootAsMovie(_bb: ByteBuffer): Movie = getRootAsMovie(_bb, Movie())
@@ -86,15 +103,17 @@ class Movie : Table() {
             return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
         }
         fun MovieBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MOVI")
-        fun createMovie(builder: FlatBufferBuilder, mainCharacterType: UByte, mainCharacterOffset: Int, charactersTypeOffset: Int, charactersOffset: Int) : Int {
-            builder.startTable(4)
+        fun createMovie(builder: FlatBufferBuilder, mainCharacterType: UByte, mainCharacterOffset: Int, charactersTypeOffset: Int, charactersOffset: Int, gadgetType: UByte, gadgetOffset: Int) : Int {
+            builder.startTable(6)
+            addGadget(builder, gadgetOffset)
             addCharacters(builder, charactersOffset)
             addCharactersType(builder, charactersTypeOffset)
             addMainCharacter(builder, mainCharacterOffset)
+            addGadgetType(builder, gadgetType)
             addMainCharacterType(builder, mainCharacterType)
             return endMovie(builder)
         }
-        fun startMovie(builder: FlatBufferBuilder) = builder.startTable(4)
+        fun startMovie(builder: FlatBufferBuilder) = builder.startTable(6)
         fun addMainCharacterType(builder: FlatBufferBuilder, mainCharacterType: UByte) = builder.addByte(0, mainCharacterType.toByte(), 0)
         fun addMainCharacter(builder: FlatBufferBuilder, mainCharacter: Int) = builder.addOffset(1, mainCharacter, 0)
         fun addCharactersType(builder: FlatBufferBuilder, charactersType: Int) = builder.addOffset(2, charactersType, 0)
@@ -116,6 +135,8 @@ class Movie : Table() {
             return builder.endVector()
         }
         fun startCharactersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
+        fun addGadgetType(builder: FlatBufferBuilder, gadgetType: UByte) = builder.addByte(4, gadgetType.toByte(), 0)
+        fun addGadget(builder: FlatBufferBuilder, gadget: Int) = builder.addOffset(5, gadget, 0)
         fun endMovie(builder: FlatBufferBuilder) : Int {
             val o = builder.endTable()
             return o
diff --git a/tests/union_vector/Movie.php b/tests/union_vector/Movie.php
index 216cd288b..0649a13f4 100644
--- a/tests/union_vector/Movie.php
+++ b/tests/union_vector/Movie.php
@@ -96,26 +96,46 @@ class Movie extends Table
         return $o != 0 ? $this->__vector_len($o) : 0;
     }
 
+    /**
+     * @return byte
+     */
+    public function getGadgetType()
+    {
+        $o = $this->__offset(12);
+        return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \Gadget::NONE;
+    }
+
+    /**
+     * @returnint
+     */
+    public function getGadget($obj)
+    {
+        $o = $this->__offset(14);
+        return $o != 0 ? $this->__union($obj, $o) : null;
+    }
+
     /**
      * @param FlatBufferBuilder $builder
      * @return void
      */
     public static function startMovie(FlatBufferBuilder $builder)
     {
-        $builder->StartObject(4);
+        $builder->StartObject(6);
     }
 
     /**
      * @param FlatBufferBuilder $builder
      * @return Movie
      */
-    public static function createMovie(FlatBufferBuilder $builder, $main_character_type, $main_character, $characters_type, $characters)
+    public static function createMovie(FlatBufferBuilder $builder, $main_character_type, $main_character, $characters_type, $characters, $gadget_type, $gadget)
     {
-        $builder->startObject(4);
+        $builder->startObject(6);
         self::addMainCharacterType($builder, $main_character_type);
         self::addMainCharacter($builder, $main_character);
         self::addCharactersType($builder, $characters_type);
         self::addCharacters($builder, $characters);
+        self::addGadgetType($builder, $gadget_type);
+        self::addGadget($builder, $gadget);
         $o = $builder->endObject();
         return $o;
     }
@@ -203,6 +223,21 @@ class Movie extends Table
         $builder->startVector(4, $numElems, 4);
     }
 
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param byte
+     * @return void
+     */
+    public static function addGadgetType(FlatBufferBuilder $builder, $gadgetType)
+    {
+        $builder->addByteX(4, $gadgetType, 0);
+    }
+
+    public static function addGadget(FlatBufferBuilder $builder, $offset)
+    {
+        $builder->addOffsetX(5, $offset, 0);
+    }
+
     /**
      * @param FlatBufferBuilder $builder
      * @return int table offset
diff --git a/tests/union_vector/MovieT.java b/tests/union_vector/MovieT.java
index 3dd85b944..7b9d3eba8 100644
--- a/tests/union_vector/MovieT.java
+++ b/tests/union_vector/MovieT.java
@@ -19,6 +19,7 @@ import java.nio.ByteOrder;
 public class MovieT {
   private CharacterUnion mainCharacter;
   private CharacterUnion[] characters;
+  private GadgetUnion gadget;
 
   public CharacterUnion getMainCharacter() { return mainCharacter; }
 
@@ -28,10 +29,15 @@ public class MovieT {
 
   public void setCharacters(CharacterUnion[] characters) { this.characters = characters; }
 
+  public GadgetUnion getGadget() { return gadget; }
+
+  public void setGadget(GadgetUnion gadget) { this.gadget = gadget; }
+
 
   public MovieT() {
     this.mainCharacter = null;
     this.characters = null;
+    this.gadget = null;
   }
   public static MovieT deserializeFromBinary(byte[] fbBuffer) {
     return Movie.getRootAsMovie(ByteBuffer.wrap(fbBuffer)).unpack();
diff --git a/tests/union_vector/union_vector.fbs b/tests/union_vector/union_vector.fbs
index 3dd384821..8d99e24e7 100644
--- a/tests/union_vector/union_vector.fbs
+++ b/tests/union_vector/union_vector.fbs
@@ -38,6 +38,7 @@ union Gadget {
 table Movie {
   main_character: Character;
   characters: [Character];
+  gadget: Gadget;
 }
 
 root_type Movie;
diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h
index 12bbb4ae9..7a7354f9f 100644
--- a/tests/union_vector/union_vector_generated.h
+++ b/tests/union_vector/union_vector_generated.h
@@ -573,6 +573,7 @@ struct MovieT : public ::flatbuffers::NativeTable {
   typedef Movie TableType;
   CharacterUnion main_character{};
   std::vector<CharacterUnion> characters{};
+  GadgetUnion gadget{};
 };
 
 struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -585,7 +586,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     VT_MAIN_CHARACTER_TYPE = 4,
     VT_MAIN_CHARACTER = 6,
     VT_CHARACTERS_TYPE = 8,
-    VT_CHARACTERS = 10
+    VT_CHARACTERS = 10,
+    VT_GADGET_TYPE = 12,
+    VT_GADGET = 14
   };
   Character main_character_type() const {
     return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
@@ -644,6 +647,29 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   }
+  Gadget gadget_type() const {
+    return static_cast<Gadget>(GetField<uint8_t>(VT_GADGET_TYPE, 0));
+  }
+  const void *gadget() const {
+    return GetPointer<const void *>(VT_GADGET);
+  }
+  template<typename T> const T *gadget_as() const;
+  const FallingTub *gadget_as_FallingTub() const {
+    return gadget_type() == Gadget_FallingTub ? static_cast<const FallingTub *>(gadget()) : nullptr;
+  }
+  const HandFan *gadget_as_HandFan() const {
+    return gadget_type() == Gadget_HandFan ? static_cast<const HandFan *>(gadget()) : nullptr;
+  }
+  void *mutable_gadget() {
+    return GetPointer<void *>(VT_GADGET);
+  }
+  template<typename T> T *mutable_gadget_as();
+  FallingTub *mutable_gadget_as_FallingTub() {
+    return gadget_type() == Gadget_FallingTub ? static_cast<FallingTub *>(mutable_gadget()) : nullptr;
+  }
+  HandFan *mutable_gadget_as_HandFan() {
+    return gadget_type() == Gadget_HandFan ? static_cast<HandFan *>(mutable_gadget()) : nullptr;
+  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
@@ -655,6 +681,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyOffset(verifier, VT_CHARACTERS) &&
            verifier.VerifyVector(characters()) &&
            VerifyCharacterVector(verifier, characters(), characters_type()) &&
+           VerifyField<uint8_t>(verifier, VT_GADGET_TYPE, 1) &&
+           VerifyOffset(verifier, VT_GADGET) &&
+           VerifyGadget(verifier, gadget(), gadget_type()) &&
            verifier.EndTable();
   }
   MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -662,6 +691,22 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
 };
 
+template<> inline const FallingTub *Movie::gadget_as<FallingTub>() const {
+  return gadget_as_FallingTub();
+}
+
+template<> inline FallingTub *Movie::mutable_gadget_as<FallingTub>() {
+  return mutable_gadget_as_FallingTub();
+}
+
+template<> inline const HandFan *Movie::gadget_as<HandFan>() const {
+  return gadget_as_HandFan();
+}
+
+template<> inline HandFan *Movie::mutable_gadget_as<HandFan>() {
+  return mutable_gadget_as_HandFan();
+}
+
 struct MovieBuilder {
   typedef Movie Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -678,6 +723,12 @@ struct MovieBuilder {
   void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
     fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
   }
+  void add_gadget_type(Gadget gadget_type) {
+    fbb_.AddElement<uint8_t>(Movie::VT_GADGET_TYPE, static_cast<uint8_t>(gadget_type), 0);
+  }
+  void add_gadget(::flatbuffers::Offset<void> gadget) {
+    fbb_.AddOffset(Movie::VT_GADGET, gadget);
+  }
   explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -694,11 +745,15 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(
     Character main_character_type = Character_NONE,
     ::flatbuffers::Offset<void> main_character = 0,
     ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0,
+    Gadget gadget_type = Gadget_NONE,
+    ::flatbuffers::Offset<void> gadget = 0) {
   MovieBuilder builder_(_fbb);
+  builder_.add_gadget(gadget);
   builder_.add_characters(characters);
   builder_.add_characters_type(characters_type);
   builder_.add_main_character(main_character);
+  builder_.add_gadget_type(gadget_type);
   builder_.add_main_character_type(main_character_type);
   return builder_.Finish();
 }
@@ -708,7 +763,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
     Character main_character_type = Character_NONE,
     ::flatbuffers::Offset<void> main_character = 0,
     const std::vector<uint8_t> *characters_type = nullptr,
-    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
+    const std::vector<::flatbuffers::Offset<void>> *characters = nullptr,
+    Gadget gadget_type = Gadget_NONE,
+    ::flatbuffers::Offset<void> gadget = 0) {
   auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0;
   auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
   return CreateMovie(
@@ -716,7 +773,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
       main_character_type,
       main_character,
       characters_type__,
-      characters__);
+      characters__,
+      gadget_type,
+      gadget);
 }
 
 ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -799,7 +858,8 @@ inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBui
 inline bool operator==(const MovieT &lhs, const MovieT &rhs) {
   return
       (lhs.main_character == rhs.main_character) &&
-      (lhs.characters == rhs.characters);
+      (lhs.characters == rhs.characters) &&
+      (lhs.gadget == rhs.gadget);
 }
 
 inline bool operator!=(const MovieT &lhs, const MovieT &rhs) {
@@ -820,6 +880,8 @@ inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t
   { auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
   { auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
   { auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
+  { auto _e = gadget_type(); _o->gadget.type = _e; }
+  { auto _e = gadget(); if (_e) _o->gadget.value = GadgetUnion::UnPack(_e, gadget_type(), _resolver); }
 }
 
 inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -834,12 +896,16 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
   auto _main_character = _o->main_character.Pack(_fbb);
   auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return static_cast<uint8_t>(__va->__o->characters[i].type); }, &_va) : 0;
   auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
+  auto _gadget_type = _o->gadget.type;
+  auto _gadget = _o->gadget.Pack(_fbb);
   return CreateMovie(
       _fbb,
       _main_character_type,
       _main_character,
       _characters_type,
-      _characters);
+      _characters,
+      _gadget_type,
+      _gadget);
 }
 
 template <bool B>
@@ -1234,19 +1300,24 @@ inline const ::flatbuffers::TypeTable *MovieTypeTable() {
     { ::flatbuffers::ET_UTYPE, 0, 0 },
     { ::flatbuffers::ET_SEQUENCE, 0, 0 },
     { ::flatbuffers::ET_UTYPE, 1, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 0 }
+    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
+    { ::flatbuffers::ET_UTYPE, 0, 1 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 1 }
   };
   static const ::flatbuffers::TypeFunction type_refs[] = {
-    CharacterTypeTable
+    CharacterTypeTable,
+    GadgetTypeTable
   };
   static const char * const names[] = {
     "main_character_type",
     "main_character",
     "characters_type",
-    "characters"
+    "characters",
+    "gadget_type",
+    "gadget"
   };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
+    ::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }