Added required-nested-flatbuffer to monster_test and fixed rust (#6236)

Co-authored-by: Casper Neo <cneo@google.com>
2026-06-01 19:58:15 +00:00 · 2020-11-05 13:58:06 -08:00
parent bc56c553ec
commit 46a8c7e958
21 changed files with 1047 additions and 542 deletions
--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
@@ -1302,13 +1302,21 @@ class RustGenerator : public BaseGenerator {

        code_.SetValue("NESTED", WrapInNameSpace(*nested_root));
        code_ +=
-            "  pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> "
-            "Option<{{NESTED}}<'a>> {";
-        code_ += "    self.{{FIELD_NAME}}().map(|data| {";
-        code_ += "      use flatbuffers::Follow;";
-        code_ += "      <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
-            "::follow(data, 0)";
-        code_ += "    })";
+            "  pub fn {{FIELD_NAME}}_nested_flatbuffer(&'a self) -> \\";
+        if (field.required) {
+          code_ += "{{NESTED}}<'a> {";
+          code_ += "    let data = self.{{FIELD_NAME}}();";
+          code_ += "    use flatbuffers::Follow;";
+          code_ += "    <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
+                   "::follow(data, 0)";
+        } else {
+          code_ += "Option<{{NESTED}}<'a>> {";
+          code_ += "    self.{{FIELD_NAME}}().map(|data| {";
+          code_ += "      use flatbuffers::Follow;";
+          code_ += "      <flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
+                   "::follow(data, 0)";
+          code_ += "    })";
+        }
        code_ += "  }";
      }
    });
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
@@ -719,6 +719,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
        case anyAmbiguous = 96
        case vectorOfEnums = 98
        case signedEnum = 100
+        case testrequirednestedflatbuffer = 102
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }
@@ -832,7 +833,11 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
    public func vectorOfEnums(at index: Int32) -> MyGame_Example_Color? { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? MyGame_Example_Color.red : MyGame_Example_Color(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
    public var signedEnum: MyGame_Example_Race { let o = _accessor.offset(VTOFFSET.signedEnum.v); return o == 0 ? .none_ : MyGame_Example_Race(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
    @discardableResult public func mutate(signedEnum: MyGame_Example_Race) -> Bool {let o = _accessor.offset(VTOFFSET.signedEnum.v);  return _accessor.mutate(signedEnum.rawValue, index: o) }
-    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 49) }
+    public var testrequirednestedflatbufferCount: Int32 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func testrequirednestedflatbuffer(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
+    public var testrequirednestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testrequirednestedflatbuffer.v) ?? [] }
+    public func mutate(testrequirednestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testrequirednestedflatbuffer.v); return _accessor.directMutate(testrequirednestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
+    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 50) }
    public static func add(pos: Offset<UOffset>?, _ fbb: inout FlatBufferBuilder) { guard pos != nil else { return }; fbb.add(structOffset: VTOFFSET.pos.p) }
    public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
    public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
@@ -891,6 +896,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
    public static func add(anyAmbiguous: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VTOFFSET.anyAmbiguous.p) }
    public static func addVectorOf(vectorOfEnums: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VTOFFSET.vectorOfEnums.p) }
    public static func add(signedEnum: MyGame_Example_Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VTOFFSET.signedEnum.p) }
+    public static func addVectorOf(testrequirednestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VTOFFSET.testrequirednestedflatbuffer.p) }
    public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
    public static func sortVectorOfMonster(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
        var off = offsets
@@ -980,6 +986,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {
        let __anyUnique = obj.anyUnique?.pack(builder: &builder) ?? Offset()
        let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
        let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
+        let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
        let __root = MyGame_Example_Monster.startMonster(&builder)
        MyGame_Example_Monster.add(pos: obj.pos.map { MyGame_Example_Vec3.createVec3(builder: &builder, x: $0.x, y: $0.y, z: $0.z, test1: $0.test1, test2: $0.test2, test3a: $0.test3.a, test3b: $0.test3.b) }, &builder)
        MyGame_Example_Monster.add(mana: obj.mana, &builder)
@@ -1038,6 +1045,7 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {

        MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
        MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
+        MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
        return MyGame_Example_Monster.endMonster(&builder, start: __root)
    }
 }
@@ -1089,6 +1097,7 @@ public class MyGame_Example_MonsterT: NativeTable {
    public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
    public var vectorOfEnums: [MyGame_Example_Color]
    public var signedEnum: MyGame_Example_Race
+    public var testrequirednestedflatbuffer: [UInt8]

    public init(_ _t: inout MyGame_Example_Monster) {
        var __pos = _t.pos
@@ -1233,6 +1242,10 @@ public class MyGame_Example_MonsterT: NativeTable {
            vectorOfEnums.append(_t.vectorOfEnums(at: index)!)
        }
        signedEnum = _t.signedEnum
+        testrequirednestedflatbuffer = []
+        for index in 0..<_t.testrequirednestedflatbufferCount {
+            testrequirednestedflatbuffer.append(_t.testrequirednestedflatbuffer(at: index))
+        }
    }

    public init() {
@@ -1278,6 +1291,7 @@ public class MyGame_Example_MonsterT: NativeTable {
        vectorOfNonOwningReferences = []
        vectorOfEnums = []
        signedEnum = .none_
+        testrequirednestedflatbuffer = []
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
--- a/tests/MyGame/Example/Monster.cs
+++ b/tests/MyGame/Example/Monster.cs
@@ -188,6 +188,16 @@ public struct Monster : IFlatbufferObject
  public bool MutateVectorOfEnums(int j, MyGame.Example.Color vector_of_enums) { int o = __p.__offset(98); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
  public MyGame.Example.Race SignedEnum { get { int o = __p.__offset(100); return o != 0 ? (MyGame.Example.Race)__p.bb.GetSbyte(o + __p.bb_pos) : MyGame.Example.Race.None; } }
  public bool MutateSignedEnum(MyGame.Example.Race signed_enum) { int o = __p.__offset(100); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, (sbyte)signed_enum); return true; } else { return false; } }
+  public byte Testrequirednestedflatbuffer(int j) { int o = __p.__offset(102); return o != 0 ? __p.bb.Get(__p.__vector(o) + j * 1) : (byte)0; }
+  public int TestrequirednestedflatbufferLength { get { int o = __p.__offset(102); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_span<byte>(102, 1); }
+#else
+  public ArraySegment<byte>? GetTestrequirednestedflatbufferBytes() { return __p.__vector_as_arraysegment(102); }
+#endif
+  public byte[] GetTestrequirednestedflatbufferArray() { return __p.__vector_as_array<byte>(102); }
+  public MyGame.Example.Monster? GetTestrequirednestedflatbufferAsMonster() { int o = __p.__offset(102); return o != 0 ? (MyGame.Example.Monster?)(new MyGame.Example.Monster()).__assign(__p.__indirect(__p.__vector(o)), __p.bb) : null; }
+  public bool MutateTestrequirednestedflatbuffer(int j, byte testrequirednestedflatbuffer) { int o = __p.__offset(102); if (o != 0) { __p.bb.Put(__p.__vector(o) + j * 1, testrequirednestedflatbuffer); return true; } else { return false; } }

  public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
      MyGame.Example.Vec3T pos = null,
@@ -237,8 +247,9 @@ public struct Monster : IFlatbufferObject
      MyGame.Example.AnyAmbiguousAliases any_ambiguous_type = MyGame.Example.AnyAmbiguousAliases.NONE,
      int any_ambiguousOffset = 0,
      VectorOffset vector_of_enumsOffset = default(VectorOffset),
-      MyGame.Example.Race signed_enum = MyGame.Example.Race.None) {
-    builder.StartTable(49);
+      MyGame.Example.Race signed_enum = MyGame.Example.Race.None,
+      VectorOffset testrequirednestedflatbufferOffset = default(VectorOffset)) {
+    builder.StartTable(50);
    Monster.AddNonOwningReference(builder, non_owning_reference);
    Monster.AddCoOwningReference(builder, co_owning_reference);
    Monster.AddSingleWeakReference(builder, single_weak_reference);
@@ -246,6 +257,7 @@ public struct Monster : IFlatbufferObject
    Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
    Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
    Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
+    Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
    Monster.AddVectorOfEnums(builder, vector_of_enumsOffset);
    Monster.AddAnyAmbiguous(builder, any_ambiguousOffset);
    Monster.AddAnyUnique(builder, any_uniqueOffset);
@@ -290,7 +302,7 @@ public struct Monster : IFlatbufferObject
    return Monster.EndMonster(builder);
  }

-  public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(49); }
+  public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(50); }
  public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
  public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
  public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
@@ -387,6 +399,10 @@ public struct Monster : IFlatbufferObject
  public static VectorOffset CreateVectorOfEnumsVectorBlock(FlatBufferBuilder builder, MyGame.Example.Color[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
  public static void StartVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
  public static void AddSignedEnum(FlatBufferBuilder builder, MyGame.Example.Race signedEnum) { builder.AddSbyte(48, (sbyte)signedEnum, -1); }
+  public static void AddTestrequirednestedflatbuffer(FlatBufferBuilder builder, VectorOffset testrequirednestedflatbufferOffset) { builder.AddOffset(49, testrequirednestedflatbufferOffset.Value, 0); }
+  public static VectorOffset CreateTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateTestrequirednestedflatbufferVectorBlock(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static void StartTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
  public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
    int o = builder.EndTable();
    builder.Required(o, 10);  // name
@@ -528,6 +544,8 @@ public struct Monster : IFlatbufferObject
    _o.VectorOfEnums = new List<MyGame.Example.Color>();
    for (var _j = 0; _j < this.VectorOfEnumsLength; ++_j) {_o.VectorOfEnums.Add(this.VectorOfEnums(_j));}
    _o.SignedEnum = this.SignedEnum;
+    _o.Testrequirednestedflatbuffer = new List<byte>();
+    for (var _j = 0; _j < this.TestrequirednestedflatbufferLength; ++_j) {_o.Testrequirednestedflatbuffer.Add(this.Testrequirednestedflatbuffer(_j));}
  }
  public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
    if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -639,6 +657,11 @@ public struct Monster : IFlatbufferObject
      var __vector_of_enums = _o.VectorOfEnums.ToArray();
      _vector_of_enums = CreateVectorOfEnumsVector(builder, __vector_of_enums);
    }
+    var _testrequirednestedflatbuffer = default(VectorOffset);
+    if (_o.Testrequirednestedflatbuffer != null) {
+      var __testrequirednestedflatbuffer = _o.Testrequirednestedflatbuffer.ToArray();
+      _testrequirednestedflatbuffer = CreateTestrequirednestedflatbufferVector(builder, __testrequirednestedflatbuffer);
+    }
    return CreateMonster(
      builder,
      _o.Pos,
@@ -688,7 +711,8 @@ public struct Monster : IFlatbufferObject
      _any_ambiguous_type,
      _any_ambiguous,
      _vector_of_enums,
-      _o.SignedEnum);
+      _o.SignedEnum,
+      _testrequirednestedflatbuffer);
  }
 };

@@ -831,6 +855,8 @@ public class MonsterT
  public List<MyGame.Example.Color> VectorOfEnums { get; set; }
  [Newtonsoft.Json.JsonProperty("signed_enum")]
  public MyGame.Example.Race SignedEnum { get; set; }
+  [Newtonsoft.Json.JsonProperty("testrequirednestedflatbuffer")]
+  public List<byte> Testrequirednestedflatbuffer { get; set; }

  public MonsterT() {
    this.Pos = new MyGame.Example.Vec3T();
@@ -878,6 +904,7 @@ public class MonsterT
    this.AnyAmbiguous = null;
    this.VectorOfEnums = null;
    this.SignedEnum = MyGame.Example.Race.None;
+    this.Testrequirednestedflatbuffer = null;
  }

  public static MonsterT DeserializeFromJson(string jsonText) {
--- a/tests/MyGame/Example/Monster.go
+++ b/tests/MyGame/Example/Monster.go
@@ -55,6 +55,7 @@ type MonsterT struct {
 	AnyAmbiguous *AnyAmbiguousAliasesT
 	VectorOfEnums []Color
 	SignedEnum Race
+	Testrequirednestedflatbuffer []byte
 }

 func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -236,6 +237,10 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 		}
 		vectorOfEnumsOffset = builder.EndVector(vectorOfEnumsLength)
 	}
+	testrequirednestedflatbufferOffset := flatbuffers.UOffsetT(0)
+	if t.Testrequirednestedflatbuffer != nil {
+		testrequirednestedflatbufferOffset = builder.CreateByteString(t.Testrequirednestedflatbuffer)
+	}
 	MonsterStart(builder)
 	posOffset := t.Pos.Pack(builder)
 	MonsterAddPos(builder, posOffset)
@@ -292,6 +297,7 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	MonsterAddAnyAmbiguous(builder, anyAmbiguousOffset)
 	MonsterAddVectorOfEnums(builder, vectorOfEnumsOffset)
 	MonsterAddSignedEnum(builder, t.SignedEnum)
+	MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset)
 	return MonsterEnd(builder)
 }

@@ -422,6 +428,7 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
 		t.VectorOfEnums[j] = rcv.VectorOfEnums(j)
 	}
 	t.SignedEnum = rcv.SignedEnum()
+	t.Testrequirednestedflatbuffer = rcv.TestrequirednestedflatbufferBytes()
 }

 func (rcv *Monster) UnPack() *MonsterT {
@@ -1256,8 +1263,42 @@ func (rcv *Monster) MutateSignedEnum(n Race) bool {
 	return rcv._tab.MutateInt8Slot(100, int8(n))
 }

+func (rcv *Monster) Testrequirednestedflatbuffer(j int) byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+	}
+	return 0
+}
+
+func (rcv *Monster) TestrequirednestedflatbufferLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Monster) TestrequirednestedflatbufferBytes() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Monster) MutateTestrequirednestedflatbuffer(j int, n byte) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(102))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+	}
+	return false
+}
+
 func MonsterStart(builder *flatbuffers.Builder) {
-	builder.StartObject(49)
+	builder.StartObject(50)
 }
 func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
 	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1457,6 +1498,12 @@ func MonsterStartVectorOfEnumsVector(builder *flatbuffers.Builder, numElems int)
 func MonsterAddSignedEnum(builder *flatbuffers.Builder, signedEnum Race) {
 	builder.PrependInt8Slot(48, int8(signedEnum), -1)
 }
+func MonsterAddTestrequirednestedflatbuffer(builder *flatbuffers.Builder, testrequirednestedflatbuffer flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(49, flatbuffers.UOffsetT(testrequirednestedflatbuffer), 0)
+}
+func MonsterStartTestrequirednestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(1, numElems, 1)
+}
 func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	return builder.EndObject()
 }
--- a/tests/MyGame/Example/Monster.java
+++ b/tests/MyGame/Example/Monster.java
@@ -194,8 +194,17 @@ public final class Monster extends Table {
  public boolean mutateVectorOfEnums(int j, int vector_of_enums) { int o = __offset(98); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)vector_of_enums); return true; } else { return false; } }
  public byte signedEnum() { int o = __offset(100); return o != 0 ? bb.get(o + bb_pos) : -1; }
  public boolean mutateSignedEnum(byte signed_enum) { int o = __offset(100); if (o != 0) { bb.put(o + bb_pos, signed_enum); return true; } else { return false; } }
+  public int testrequirednestedflatbuffer(int j) { int o = __offset(102); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int testrequirednestedflatbufferLength() { int o = __offset(102); return o != 0 ? __vector_len(o) : 0; }
+  public ByteVector testrequirednestedflatbufferVector() { return testrequirednestedflatbufferVector(new ByteVector()); }
+  public ByteVector testrequirednestedflatbufferVector(ByteVector obj) { int o = __offset(102); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer testrequirednestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(102, 1); }
+  public ByteBuffer testrequirednestedflatbufferInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 102, 1); }
+  public MyGame.Example.Monster testrequirednestedflatbufferAsMonster() { return testrequirednestedflatbufferAsMonster(new MyGame.Example.Monster()); }
+  public MyGame.Example.Monster testrequirednestedflatbufferAsMonster(MyGame.Example.Monster obj) { int o = __offset(102); return o != 0 ? obj.__assign(__indirect(__vector(o)), bb) : null; }
+  public boolean mutateTestrequirednestedflatbuffer(int j, int testrequirednestedflatbuffer) { int o = __offset(102); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)testrequirednestedflatbuffer); return true; } else { return false; } }

-  public static void startMonster(FlatBufferBuilder builder) { builder.startTable(49); }
+  public static void startMonster(FlatBufferBuilder builder) { builder.startTable(50); }
  public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
  public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
  public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
@@ -281,6 +290,10 @@ public final class Monster extends Table {
  public static int createVectorOfEnumsVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
  public static void startVectorOfEnumsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
  public static void addSignedEnum(FlatBufferBuilder builder, byte signedEnum) { builder.addByte(48, signedEnum, -1); }
+  public static void addTestrequirednestedflatbuffer(FlatBufferBuilder builder, int testrequirednestedflatbufferOffset) { builder.addOffset(49, testrequirednestedflatbufferOffset, 0); }
+  public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+  public static int createTestrequirednestedflatbufferVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+  public static void startTestrequirednestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
  public static int endMonster(FlatBufferBuilder builder) {
    int o = builder.endTable();
    builder.required(o, 10);  // name
--- a/tests/MyGame/Example/Monster.kt
+++ b/tests/MyGame/Example/Monster.kt
@@ -773,6 +773,38 @@ class Monster : Table() {
            false
        }
    }
+    fun testrequirednestedflatbuffer(j: Int) : UByte {
+        val o = __offset(102)
+        return if (o != 0) {
+            bb.get(__vector(o) + j * 1).toUByte()
+        } else {
+            0u
+        }
+    }
+    val testrequirednestedflatbufferLength : Int
+        get() {
+            val o = __offset(102); return if (o != 0) __vector_len(o) else 0
+        }
+    val testrequirednestedflatbufferAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(102, 1)
+    fun testrequirednestedflatbufferInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 102, 1)
+    val testrequirednestedflatbufferAsMonster : MyGame.Example.Monster? get() = testrequirednestedflatbufferAsMonster(MyGame.Example.Monster())
+    fun testrequirednestedflatbufferAsMonster(obj: MyGame.Example.Monster) : MyGame.Example.Monster? {
+        val o = __offset(102)
+        return if (o != 0) {
+            obj.__assign(__indirect(__vector(o)), bb)
+        } else {
+            null
+        }
+    }
+    fun mutateTestrequirednestedflatbuffer(j: Int, testrequirednestedflatbuffer: UByte) : Boolean {
+        val o = __offset(102)
+        return if (o != 0) {
+            bb.put(__vector(o) + j * 1, testrequirednestedflatbuffer.toByte())
+            true
+        } else {
+            false
+        }
+    }
    override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
         return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
    }
@@ -784,7 +816,7 @@ class Monster : Table() {
            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
        }
        fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
-        fun startMonster(builder: FlatBufferBuilder) = builder.startTable(49)
+        fun startMonster(builder: FlatBufferBuilder) = builder.startTable(50)
        fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
        fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
        fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
@@ -956,6 +988,15 @@ class Monster : Table() {
        }
        fun startVectorOfEnumsVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
        fun addSignedEnum(builder: FlatBufferBuilder, signedEnum: Byte) = builder.addByte(48, signedEnum, -1)
+        fun addTestrequirednestedflatbuffer(builder: FlatBufferBuilder, testrequirednestedflatbuffer: Int) = builder.addOffset(49, testrequirednestedflatbuffer, 0)
+        fun createTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, data: UByteArray) : Int {
+            builder.startVector(1, data.size, 1)
+            for (i in data.size - 1 downTo 0) {
+                builder.addByte(data[i].toByte())
+            }
+            return builder.endVector()
+        }
+        fun startTestrequirednestedflatbufferVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(1, numElems, 1)
        fun endMonster(builder: FlatBufferBuilder) : Int {
            val o = builder.endTable()
                builder.required(o, 10)
--- a/tests/MyGame/Example/Monster.lua
+++ b/tests/MyGame/Example/Monster.lua
@@ -529,7 +529,22 @@ function Monster_mt:SignedEnum()
    end
    return -1
 end
-function Monster.Start(builder) builder:StartObject(49) end
+function Monster_mt:Testrequirednestedflatbuffer(j)
+    local o = self.view:Offset(102)
+    if o ~= 0 then
+        local a = self.view:Vector(o)
+        return self.view:Get(flatbuffers.N.Uint8, a + ((j-1) * 1))
+    end
+    return 0
+end
+function Monster_mt:TestrequirednestedflatbufferLength()
+    local o = self.view:Offset(102)
+    if o ~= 0 then
+        return self.view:VectorLen(o)
+    end
+    return 0
+end
+function Monster.Start(builder) builder:StartObject(50) end
 function Monster.AddPos(builder, pos) builder:PrependStructSlot(0, pos, 0) end
 function Monster.AddMana(builder, mana) builder:PrependInt16Slot(1, mana, 150) end
 function Monster.AddHp(builder, hp) builder:PrependInt16Slot(2, hp, 100) end
@@ -596,6 +611,8 @@ function Monster.AddAnyAmbiguous(builder, anyAmbiguous) builder:PrependUOffsetTR
 function Monster.AddVectorOfEnums(builder, vectorOfEnums) builder:PrependUOffsetTRelativeSlot(47, vectorOfEnums, 0) end
 function Monster.StartVectorOfEnumsVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
 function Monster.AddSignedEnum(builder, signedEnum) builder:PrependInt8Slot(48, signedEnum, -1) end
+function Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) builder:PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer, 0) end
+function Monster.StartTestrequirednestedflatbufferVector(builder, numElems) return builder:StartVector(1, numElems, 1) end
 function Monster.End(builder) return builder:EndObject() end

 return Monster -- return the module
--- a/tests/MyGame/Example/Monster.php
+++ b/tests/MyGame/Example/Monster.php
@@ -683,22 +683,49 @@ class Monster extends Table
        return $o != 0 ? $this->bb->getSbyte($o + $this->bb_pos) : \MyGame\Example\Race::None;
    }

+    /**
+     * @param int offset
+     * @return byte
+     */
+    public function getTestrequirednestedflatbuffer($j)
+    {
+        $o = $this->__offset(102);
+        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
+    }
+
+    /**
+     * @return int
+     */
+    public function getTestrequirednestedflatbufferLength()
+    {
+        $o = $this->__offset(102);
+        return $o != 0 ? $this->__vector_len($o) : 0;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTestrequirednestedflatbufferBytes()
+    {
+        return $this->__vector_as_bytes(102);
+    }
+
    /**
     * @param FlatBufferBuilder $builder
     * @return void
     */
    public static function startMonster(FlatBufferBuilder $builder)
    {
-        $builder->StartObject(49);
+        $builder->StartObject(50);
    }

    /**
     * @param FlatBufferBuilder $builder
     * @return Monster
     */
-    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum)
+    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer)
    {
-        $builder->startObject(49);
+        $builder->startObject(50);
        self::addPos($builder, $pos);
        self::addMana($builder, $mana);
        self::addHp($builder, $hp);
@@ -747,6 +774,7 @@ class Monster extends Table
        self::addAnyAmbiguous($builder, $any_ambiguous);
        self::addVectorOfEnums($builder, $vector_of_enums);
        self::addSignedEnum($builder, $signed_enum);
+        self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
        $o = $builder->endObject();
        $builder->required($o, 10);  // name
        return $o;
@@ -1649,6 +1677,40 @@ class Monster extends Table
        $builder->addSbyteX(48, $signedEnum, -1);
    }

+    /**
+     * @param FlatBufferBuilder $builder
+     * @param VectorOffset
+     * @return void
+     */
+    public static function addTestrequirednestedflatbuffer(FlatBufferBuilder $builder, $testrequirednestedflatbuffer)
+    {
+        $builder->addOffsetX(49, $testrequirednestedflatbuffer, 0);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param array offset array
+     * @return int vector offset
+     */
+    public static function createTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, array $data)
+    {
+        $builder->startVector(1, count($data), 1);
+        for ($i = count($data) - 1; $i >= 0; $i--) {
+            $builder->putByte($data[$i]);
+        }
+        return $builder->endVector();
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param int $numElems
+     * @return void
+     */
+    public static function startTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
+    {
+        $builder->startVector(1, $numElems, 1);
+    }
+
    /**
     * @param FlatBufferBuilder $builder
     * @return int table offset
--- a/tests/MyGame/Example/Monster.py
+++ b/tests/MyGame/Example/Monster.py
@@ -719,7 +719,34 @@ class Monster(object):
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return -1

-def MonsterStart(builder): builder.StartObject(49)
+    # Monster
+    def Testrequirednestedflatbuffer(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Monster
+    def TestrequirednestedflatbufferAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Monster
+    def TestrequirednestedflatbufferLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Monster
+    def TestrequirednestedflatbufferIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
+        return o == 0
+
+def MonsterStart(builder): builder.StartObject(50)
 def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
 def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
@@ -786,6 +813,8 @@ def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelati
 def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
 def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
 def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
+def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
 def MonsterEnd(builder): return builder.EndObject()

 import MyGame.Example.Ability
@@ -856,6 +885,7 @@ class MonsterT(object):
        self.anyAmbiguous = None  # type: Union[None, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT, MyGame.Example.Monster.MonsterT]
        self.vectorOfEnums = None  # type: List[int]
        self.signedEnum = -1  # type: int
+        self.testrequirednestedflatbuffer = None  # type: List[int]

    @classmethod
    def InitFromBuf(cls, buf, pos):
@@ -1033,6 +1063,13 @@ class MonsterT(object):
            else:
                self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
        self.signedEnum = monster.SignedEnum()
+        if not monster.TestrequirednestedflatbufferIsNone():
+            if np is None:
+                self.testrequirednestedflatbuffer = []
+                for i in range(monster.TestrequirednestedflatbufferLength()):
+                    self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
+            else:
+                self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()

    # MonsterT
    def Pack(self, builder):
@@ -1185,6 +1222,14 @@ class MonsterT(object):
                for i in reversed(range(len(self.vectorOfEnums))):
                    builder.PrependUint8(self.vectorOfEnums[i])
                vectorOfEnums = builder.EndVector(len(self.vectorOfEnums))
+        if self.testrequirednestedflatbuffer is not None:
+            if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
+                testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
+            else:
+                MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
+                for i in reversed(range(len(self.testrequirednestedflatbuffer))):
+                    builder.PrependUint8(self.testrequirednestedflatbuffer[i])
+                testrequirednestedflatbuffer = builder.EndVector(len(self.testrequirednestedflatbuffer))
        MonsterStart(builder)
        if self.pos is not None:
            pos = self.pos.Pack(builder)
@@ -1261,5 +1306,7 @@ class MonsterT(object):
        if self.vectorOfEnums is not None:
            MonsterAddVectorOfEnums(builder, vectorOfEnums)
        MonsterAddSignedEnum(builder, self.signedEnum)
+        if self.testrequirednestedflatbuffer is not None:
+            MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
        monster = MonsterEnd(builder)
        return monster
--- a/tests/cpp17/generated_cpp17/monster_test_generated.h
+++ b/tests/cpp17/generated_cpp17/monster_test_generated.h
@@ -1016,6 +1016,7 @@ struct MonsterT : public flatbuffers::NativeTable {
  MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{};
  std::vector<MyGame::Example::Color> vector_of_enums{};
  MyGame::Example::Race signed_enum = MyGame::Example::Race::None;
+  std::vector<uint8_t> testrequirednestedflatbuffer{};
 };

 /// an example documentation comment: "monster object"
@@ -1074,7 +1075,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    VT_ANY_AMBIGUOUS_TYPE = 94,
    VT_ANY_AMBIGUOUS = 96,
    VT_VECTOR_OF_ENUMS = 98,
-    VT_SIGNED_ENUM = 100
+    VT_SIGNED_ENUM = 100,
+    VT_TESTREQUIREDNESTEDFLATBUFFER = 102
  };
  const MyGame::Example::Vec3 *pos() const {
    return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1398,6 +1400,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool mutate_signed_enum(MyGame::Example::Race _signed_enum) {
    return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
  }
+  const flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
+  }
+  const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
+    return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
+  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1478,6 +1489,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
           VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
           verifier.VerifyVector(vector_of_enums()) &&
           VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
+           VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
+           verifier.VerifyVector(testrequirednestedflatbuffer()) &&
           verifier.EndTable();
  }
  MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1657,6 +1670,9 @@ struct MonsterBuilder {
  void add_signed_enum(MyGame::Example::Race signed_enum) {
    fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
  }
+  void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
+    fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
+  }
  explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
@@ -1718,7 +1734,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
    flatbuffers::Offset<void> any_ambiguous = 0,
    flatbuffers::Offset<flatbuffers::Vector<MyGame::Example::Color>> vector_of_enums = 0,
-    MyGame::Example::Race signed_enum = MyGame::Example::Race::None) {
+    MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
  MonsterBuilder builder_(_fbb);
  builder_.add_non_owning_reference(non_owning_reference);
  builder_.add_co_owning_reference(co_owning_reference);
@@ -1727,6 +1744,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(
  builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
  builder_.add_testhashu64_fnv1(testhashu64_fnv1);
  builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
  builder_.add_vector_of_enums(vector_of_enums);
  builder_.add_any_ambiguous(any_ambiguous);
  builder_.add_any_unique(any_unique);
@@ -1825,7 +1843,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases::NONE,
    flatbuffers::Offset<void> any_ambiguous = 0,
    const std::vector<MyGame::Example::Color> *vector_of_enums = nullptr,
-    MyGame::Example::Race signed_enum = MyGame::Example::Race::None) {
+    MyGame::Example::Race signed_enum = MyGame::Example::Race::None,
+    const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
  auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -1845,6 +1864,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
  auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
  auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
  auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<MyGame::Example::Color>(*vector_of_enums) : 0;
+  auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
  return MyGame::Example::CreateMonster(
      _fbb,
      pos,
@@ -1894,7 +1914,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
      any_ambiguous_type,
      any_ambiguous,
      vector_of_enums__,
-      signed_enum);
+      signed_enum,
+      testrequirednestedflatbuffer__);
 }

 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2353,6 +2374,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
  { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
  { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<MyGame::Example::Color>(_e->Get(_i)); } } }
  { auto _e = signed_enum(); _o->signed_enum = _e; }
+  { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
 }

 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2411,6 +2433,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
  auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
  auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVector(_o->vector_of_enums) : 0;
  auto _signed_enum = _o->signed_enum;
+  auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
  return MyGame::Example::CreateMonster(
      _fbb,
      _pos,
@@ -2460,7 +2483,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
      _any_ambiguous_type,
      _any_ambiguous,
      _vector_of_enums,
-      _signed_enum);
+      _signed_enum,
+      _testrequirednestedflatbuffer);
 }

 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3147,7 +3171,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    { flatbuffers::ET_UTYPE, 0, 10 },
    { flatbuffers::ET_SEQUENCE, 0, 10 },
    { flatbuffers::ET_UCHAR, 1, 1 },
-    { flatbuffers::ET_CHAR, 0, 11 }
+    { flatbuffers::ET_CHAR, 0, 11 },
+    { flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    MyGame::Example::Vec3TypeTable,
@@ -3212,10 +3237,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    "any_ambiguous_type",
    "any_ambiguous",
    "vector_of_enums",
-    "signed_enum"
+    "signed_enum",
+    "testrequirednestedflatbuffer"
  };
  static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 49, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 50, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
 }
--- a/tests/monster_test.bfbs
+++ b/tests/monster_test.bfbs
--- a/tests/monster_test.fbs
+++ b/tests/monster_test.fbs
@@ -116,6 +116,7 @@ table Monster {
  any_ambiguous:AnyAmbiguousAliases (id:46);
  vector_of_enums:[Color] (id:47);
  signed_enum:Race = None (id:48);
+  testrequirednestedflatbuffer:[ubyte] (id:49, nested_flatbuffer: "Monster");
 }

 table TypeAliases {
--- a/tests/monster_test.schema.json
+++ b/tests/monster_test.schema.json
@@ -296,6 +296,9 @@
              },
        "signed_enum" : {
                "$ref" : "#/definitions/MyGame_Example_Race"
+              },
+        "testrequirednestedflatbuffer" : {
+                "type" : "array", "items" : {"type" : "integer", "minimum" : 0, "maximum" :255"}
              }
      },
      "required" : ["name"],
--- a/tests/monster_test_bfbs_generated.h
+++ b/tests/monster_test_bfbs_generated.h
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -1202,6 +1202,7 @@ struct MonsterT : public flatbuffers::NativeTable {
  MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous;
  std::vector<MyGame::Example::Color> vector_of_enums;
  MyGame::Example::Race signed_enum;
+  std::vector<uint8_t> testrequirednestedflatbuffer;
  MonsterT()
      : mana(150),
        hp(100),
@@ -1271,7 +1272,8 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
      (lhs.any_unique == rhs.any_unique) &&
      (lhs.any_ambiguous == rhs.any_ambiguous) &&
      (lhs.vector_of_enums == rhs.vector_of_enums) &&
-      (lhs.signed_enum == rhs.signed_enum);
+      (lhs.signed_enum == rhs.signed_enum) &&
+      (lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer);
 }

 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -1334,7 +1336,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    VT_ANY_AMBIGUOUS_TYPE = 94,
    VT_ANY_AMBIGUOUS = 96,
    VT_VECTOR_OF_ENUMS = 98,
-    VT_SIGNED_ENUM = 100
+    VT_SIGNED_ENUM = 100,
+    VT_TESTREQUIREDNESTEDFLATBUFFER = 102
  };
  const MyGame::Example::Vec3 *pos() const {
    return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1658,6 +1661,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool mutate_signed_enum(MyGame::Example::Race _signed_enum) {
    return SetField<int8_t>(VT_SIGNED_ENUM, static_cast<int8_t>(_signed_enum), -1);
  }
+  const flatbuffers::Vector<uint8_t> *testrequirednestedflatbuffer() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
+  }
+  flatbuffers::Vector<uint8_t> *mutable_testrequirednestedflatbuffer() {
+    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_TESTREQUIREDNESTEDFLATBUFFER);
+  }
+  const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const {
+    return flatbuffers::GetRoot<MyGame::Example::Monster>(testrequirednestedflatbuffer()->Data());
+  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<MyGame::Example::Vec3>(verifier, VT_POS) &&
@@ -1738,6 +1750,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
           VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) &&
           verifier.VerifyVector(vector_of_enums()) &&
           VerifyField<int8_t>(verifier, VT_SIGNED_ENUM) &&
+           VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
+           verifier.VerifyVector(testrequirednestedflatbuffer()) &&
           verifier.EndTable();
  }
  MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -1917,6 +1931,9 @@ struct MonsterBuilder {
  void add_signed_enum(MyGame::Example::Race signed_enum) {
    fbb_.AddElement<int8_t>(Monster::VT_SIGNED_ENUM, static_cast<int8_t>(signed_enum), -1);
  }
+  void add_testrequirednestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer) {
+    fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
+  }
  explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
@@ -1978,7 +1995,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
    flatbuffers::Offset<void> any_ambiguous = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> vector_of_enums = 0,
-    MyGame::Example::Race signed_enum = MyGame::Example::Race_None) {
+    MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testrequirednestedflatbuffer = 0) {
  MonsterBuilder builder_(_fbb);
  builder_.add_non_owning_reference(non_owning_reference);
  builder_.add_co_owning_reference(co_owning_reference);
@@ -1987,6 +2005,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(
  builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
  builder_.add_testhashu64_fnv1(testhashu64_fnv1);
  builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
  builder_.add_vector_of_enums(vector_of_enums);
  builder_.add_any_ambiguous(any_ambiguous);
  builder_.add_any_unique(any_unique);
@@ -2080,7 +2099,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
    MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE,
    flatbuffers::Offset<void> any_ambiguous = 0,
    const std::vector<uint8_t> *vector_of_enums = nullptr,
-    MyGame::Example::Race signed_enum = MyGame::Example::Race_None) {
+    MyGame::Example::Race signed_enum = MyGame::Example::Race_None,
+    const std::vector<uint8_t> *testrequirednestedflatbuffer = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
  auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2100,6 +2120,7 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
  auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_co_owning_references) : 0;
  auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector<uint64_t>(*vector_of_non_owning_references) : 0;
  auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector<uint8_t>(*vector_of_enums) : 0;
+  auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector<uint8_t>(*testrequirednestedflatbuffer) : 0;
  return MyGame::Example::CreateMonster(
      _fbb,
      pos,
@@ -2149,7 +2170,8 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
      any_ambiguous_type,
      any_ambiguous,
      vector_of_enums__,
-      signed_enum);
+      signed_enum,
+      testrequirednestedflatbuffer__);
 }

 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2635,6 +2657,7 @@ if (_resolver) (*_resolver)(reinterpret_cast<void **>(&_o->vector_of_non_owning_
  { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); }
  { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast<MyGame::Example::Color>(_e->Get(_i)); } } }
  { auto _e = signed_enum(); _o->signed_enum = _e; }
+  { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } }
 }

 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -2693,6 +2716,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
  auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb);
  auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast<uint8_t>(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0;
  auto _signed_enum = _o->signed_enum;
+  auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0;
  return MyGame::Example::CreateMonster(
      _fbb,
      _pos,
@@ -2742,7 +2766,8 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
      _any_ambiguous_type,
      _any_ambiguous,
      _vector_of_enums,
-      _signed_enum);
+      _signed_enum,
+      _testrequirednestedflatbuffer);
 }

 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3429,7 +3454,8 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    { flatbuffers::ET_UTYPE, 0, 10 },
    { flatbuffers::ET_SEQUENCE, 0, 10 },
    { flatbuffers::ET_UCHAR, 1, 1 },
-    { flatbuffers::ET_CHAR, 0, 11 }
+    { flatbuffers::ET_CHAR, 0, 11 },
+    { flatbuffers::ET_UCHAR, 1, -1 }
  };
  static const flatbuffers::TypeFunction type_refs[] = {
    MyGame::Example::Vec3TypeTable,
@@ -3494,10 +3520,11 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
    "any_ambiguous_type",
    "any_ambiguous",
    "vector_of_enums",
-    "signed_enum"
+    "signed_enum",
+    "testrequirednestedflatbuffer"
  };
  static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 49, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 50, type_codes, type_refs, nullptr, nullptr, names
  };
  return &tt;
 }
--- a/tests/monster_test_generated.js
+++ b/tests/monster_test_generated.js
@@ -1904,11 +1904,36 @@ MyGame.Example.Monster.prototype.mutate_signed_enum = function(value) {
  return true;
 };

+/**
+ * @param {number} index
+ * @returns {number}
+ */
+MyGame.Example.Monster.prototype.testrequirednestedflatbuffer = function(index) {
+  var offset = this.bb.__offset(this.bb_pos, 102);
+  return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+};
+
+/**
+ * @returns {number}
+ */
+MyGame.Example.Monster.prototype.testrequirednestedflatbufferLength = function() {
+  var offset = this.bb.__offset(this.bb_pos, 102);
+  return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns {Uint8Array}
+ */
+MyGame.Example.Monster.prototype.testrequirednestedflatbufferArray = function() {
+  var offset = this.bb.__offset(this.bb_pos, 102);
+  return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+};
+
 /**
 * @param {flatbuffers.Builder} builder
 */
 MyGame.Example.Monster.startMonster = function(builder) {
-  builder.startObject(49);
+  builder.startObject(50);
 };

 /**
@@ -2634,6 +2659,35 @@ MyGame.Example.Monster.addSignedEnum = function(builder, signedEnum) {
  builder.addFieldInt8(48, signedEnum, MyGame.Example.Race.None);
 };

+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {flatbuffers.Offset} testrequirednestedflatbufferOffset
+ */
+MyGame.Example.Monster.addTestrequirednestedflatbuffer = function(builder, testrequirednestedflatbufferOffset) {
+  builder.addFieldOffset(49, testrequirednestedflatbufferOffset, 0);
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {Array.<number>} data
+ * @returns {flatbuffers.Offset}
+ */
+MyGame.Example.Monster.createTestrequirednestedflatbufferVector = function(builder, data) {
+  builder.startVector(1, data.length, 1);
+  for (var i = data.length - 1; i >= 0; i--) {
+    builder.addInt8(data[i]);
+  }
+  return builder.endVector();
+};
+
+/**
+ * @param {flatbuffers.Builder} builder
+ * @param {number} numElems
+ */
+MyGame.Example.Monster.startTestrequirednestedflatbufferVector = function(builder, numElems) {
+  builder.startVector(1, numElems, 1);
+};
+
 /**
 * @param {flatbuffers.Builder} builder
 * @returns {flatbuffers.Offset}
--- a/tests/monster_test_generated.lobster
+++ b/tests/monster_test_generated.lobster
@@ -360,13 +360,17 @@ class Monster : flatbuffers_handle
        return buf_.flatbuffers_field_vector_len(pos_, 98)
    def signed_enum():
        return Race(buf_.flatbuffers_field_int8(pos_, 100, -1))
+    def testrequirednestedflatbuffer(i:int):
+        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 102) + i * 1)
+    def testrequirednestedflatbuffer_length():
+        return buf_.flatbuffers_field_vector_len(pos_, 102)

 def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }

 struct MonsterBuilder:
    b_:flatbuffers_builder
    def start():
-        b_.StartObject(49)
+        b_.StartObject(50)
        return this
    def add_pos(pos:flatbuffers_offset):
        b_.PrependStructSlot(0, pos)
@@ -512,6 +516,9 @@ struct MonsterBuilder:
    def add_signed_enum(signed_enum:Race):
        b_.PrependInt8Slot(48, signed_enum, -1)
        return this
+    def add_testrequirednestedflatbuffer(testrequirednestedflatbuffer:flatbuffers_offset):
+        b_.PrependUOffsetTRelativeSlot(49, testrequirednestedflatbuffer)
+        return this
    def end():
        return b_.EndObject()

@@ -629,6 +636,13 @@ def MonsterCreateVectorOfEnumsVector(b_:flatbuffers_builder, v_:[Color]):
    reverse(v_) e_: b_.PrependUint8(e_)
    return b_.EndVector(v_.length)

+def MonsterStartTestrequirednestedflatbufferVector(b_:flatbuffers_builder, n_:int):
+    b_.StartVector(1, n_, 1)
+def MonsterCreateTestrequirednestedflatbufferVector(b_:flatbuffers_builder, v_:[int]):
+    b_.StartVector(1, v_.length, 1)
+    reverse(v_) e_: b_.PrependUint8(e_)
+    return b_.EndVector(v_.length)
+
 class TypeAliases : flatbuffers_handle
    def i8():
        return buf_.flatbuffers_field_int8(pos_, 4, 0)
--- a/tests/monster_test_generated.rs
+++ b/tests/monster_test_generated.rs
@@ -1143,6 +1143,7 @@ impl<'a> Monster<'a> {
      builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
      builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
      builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
+      if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
      if let Some(x) = args.vector_of_enums { builder.add_vector_of_enums(x); }
      if let Some(x) = args.any_ambiguous { builder.add_any_ambiguous(x); }
      if let Some(x) = args.any_unique { builder.add_any_unique(x); }
@@ -1235,6 +1236,7 @@ impl<'a> Monster<'a> {
    pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
    pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
    pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
+    pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;

  #[inline]
  pub fn pos(&self) -> Option<&'a Vec3> {
@@ -1447,6 +1449,16 @@ impl<'a> Monster<'a> {
    self._tab.get::<Race>(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()
  }
  #[inline]
+  pub fn testrequirednestedflatbuffer(&self) -> Option<&'a [u8]> {
+    self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, None).map(|v| v.safe_slice())
+  }
+  pub fn testrequirednestedflatbuffer_nested_flatbuffer(&'a self) -> Option<Monster<'a>> {
+    self.testrequirednestedflatbuffer().map(|data| {
+      use flatbuffers::Follow;
+      <flatbuffers::ForwardsUOffset<Monster<'a>>>::follow(data, 0)
+    })
+  }
+  #[inline]
  #[allow(non_snake_case)]
  pub fn test_as_monster(&self) -> Option<Monster<'a>> {
    if self.test_type() == Any::Monster {
@@ -1587,6 +1599,7 @@ pub struct MonsterArgs<'a> {
    pub any_ambiguous: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
    pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Color>>>,
    pub signed_enum: Race,
+    pub testrequirednestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
 }
 impl<'a> Default for MonsterArgs<'a> {
    #[inline]
@@ -1640,6 +1653,7 @@ impl<'a> Default for MonsterArgs<'a> {
            any_ambiguous: None,
            vector_of_enums: None,
            signed_enum: Race::None,
+            testrequirednestedflatbuffer: None,
        }
    }
 }
@@ -1841,6 +1855,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
    self.fbb_.push_slot::<Race>(Monster::VT_SIGNED_ENUM, signed_enum, Race::None);
  }
  #[inline]
+  pub fn add_testrequirednestedflatbuffer(&mut self, testrequirednestedflatbuffer: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer);
+  }
+  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
    let start = _fbb.start_table();
    MonsterBuilder {
@@ -1985,6 +2003,7 @@ impl std::fmt::Debug for Monster<'_> {
      };
      ds.field("vector_of_enums", &self.vector_of_enums());
      ds.field("signed_enum", &self.signed_enum());
+      ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
      ds.finish()
  }
 }
--- a/tests/monster_test_generated.ts
+++ b/tests/monster_test_generated.ts
@@ -2200,11 +2200,36 @@ mutate_signed_enum(value:MyGame.Example.Race):boolean {
  return true;
 };

+/**
+ * @param number index
+ * @returns number
+ */
+testrequirednestedflatbuffer(index: number):number|null {
+  var offset = this.bb!.__offset(this.bb_pos, 102);
+  return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
+};
+
+/**
+ * @returns number
+ */
+testrequirednestedflatbufferLength():number {
+  var offset = this.bb!.__offset(this.bb_pos, 102);
+  return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
+};
+
+/**
+ * @returns Uint8Array
+ */
+testrequirednestedflatbufferArray():Uint8Array|null {
+  var offset = this.bb!.__offset(this.bb_pos, 102);
+  return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
+};
+
 /**
 * @param flatbuffers.Builder builder
 */
 static startMonster(builder:flatbuffers.Builder) {
-  builder.startObject(49);
+  builder.startObject(50);
 };

 /**
@@ -2935,6 +2960,35 @@ static addSignedEnum(builder:flatbuffers.Builder, signedEnum:MyGame.Example.Race
  builder.addFieldInt8(48, signedEnum, MyGame.Example.Race.None);
 };

+/**
+ * @param flatbuffers.Builder builder
+ * @param flatbuffers.Offset testrequirednestedflatbufferOffset
+ */
+static addTestrequirednestedflatbuffer(builder:flatbuffers.Builder, testrequirednestedflatbufferOffset:flatbuffers.Offset) {
+  builder.addFieldOffset(49, testrequirednestedflatbufferOffset, 0);
+};
+
+/**
+ * @param flatbuffers.Builder builder
+ * @param Array.<number> data
+ * @returns flatbuffers.Offset
+ */
+static createTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset {
+  builder.startVector(1, data.length, 1);
+  for (var i = data.length - 1; i >= 0; i--) {
+    builder.addInt8(data[i]);
+  }
+  return builder.endVector();
+};
+
+/**
+ * @param flatbuffers.Builder builder
+ * @param number numElems
+ */
+static startTestrequirednestedflatbufferVector(builder:flatbuffers.Builder, numElems:number) {
+  builder.startVector(1, numElems, 1);
+};
+
 /**
 * @param flatbuffers.Builder builder
 * @returns flatbuffers.Offset
@@ -3034,7 +3088,8 @@ unpack(): MonsterT {
      return temp.unpack()
  })(),
    this.bb!.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()),
-    this.signedEnum()
+    this.signedEnum(),
+    this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength())
  );
 };

@@ -3102,6 +3157,7 @@ unpackTo(_o: MonsterT): void {
  })();
  _o.vectorOfEnums = this.bb!.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength());
  _o.signedEnum = this.signedEnum();
+  _o.testrequirednestedflatbuffer = this.bb!.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength());
 };
 }

@@ -3156,6 +3212,7 @@ export class MonsterT {
 * @param MyGame.Example.MonsterT|null anyAmbiguous
 * @param (MyGame.Example.Color)[] vectorOfEnums
 * @param MyGame.Example.Race signedEnum
+ * @param (number)[] testrequirednestedflatbuffer
 */
 constructor(
  public pos: MyGame.Example.Vec3T|null = null,
@@ -3205,7 +3262,8 @@ constructor(
  public anyAmbiguousType: MyGame.Example.AnyAmbiguousAliases = MyGame.Example.AnyAmbiguousAliases.NONE,
  public anyAmbiguous: MyGame.Example.MonsterT|null = null,
  public vectorOfEnums: (MyGame.Example.Color)[] = [],
-  public signedEnum: MyGame.Example.Race = MyGame.Example.Race.None
+  public signedEnum: MyGame.Example.Race = MyGame.Example.Race.None,
+  public testrequirednestedflatbuffer: (number)[] = []
 ){};

 /**
@@ -3235,6 +3293,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
  const anyUnique = builder.createObjectOffset(this.anyUnique);
  const anyAmbiguous = builder.createObjectOffset(this.anyAmbiguous);
  const vectorOfEnums = MyGame.Example.Monster.createVectorOfEnumsVector(builder, this.vectorOfEnums);
+  const testrequirednestedflatbuffer = MyGame.Example.Monster.createTestrequirednestedflatbufferVector(builder, this.testrequirednestedflatbuffer);

  MyGame.Example.Monster.start(builder);
  MyGame.Example.Monster.addPos(builder, (this.pos !== null ? this.pos!.pack(builder) : 0));
@@ -3285,6 +3344,7 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
  MyGame.Example.Monster.addAnyAmbiguous(builder, anyAmbiguous);
  MyGame.Example.Monster.addVectorOfEnums(builder, vectorOfEnums);
  MyGame.Example.Monster.addSignedEnum(builder, this.signedEnum);
+  MyGame.Example.Monster.addTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer);

  return MyGame.Example.Monster.end(builder);
 };
--- a/tests/monster_test_my_game.example_generated.dart
+++ b/tests/monster_test_my_game.example_generated.dart
@@ -801,10 +801,11 @@ class Monster {
  }
  List<Color> get vectorOfEnums => const fb.ListReader<Color>(Color.reader).vTableGet(_bc, _bcOffset, 98, null);
  Race get signedEnum => new Race.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 100, -1));
+  List<int> get testrequirednestedflatbuffer => const fb.ListReader<int>(const fb.Uint8Reader()).vTableGet(_bc, _bcOffset, 102, null);

  @override
  String toString() {
-    return 'Monster{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}';
+    return 'Monster{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}';
  }
 }

@@ -1019,6 +1020,10 @@ class MonsterBuilder {
    fbBuilder.addInt8(48, signedEnum?.value);
    return fbBuilder.offset;
  }
+  int addTestrequirednestedflatbufferOffset(int offset) {
+    fbBuilder.addOffset(49, offset);
+    return fbBuilder.offset;
+  }

  int finish() {
    return fbBuilder.endTable();
@@ -1074,6 +1079,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
  final dynamic _anyAmbiguous;
  final List<Color> _vectorOfEnums;
  final Race _signedEnum;
+  final List<int> _testrequirednestedflatbuffer;

  MonsterObjectBuilder({
    Vec3ObjectBuilder pos,
@@ -1124,6 +1130,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    dynamic anyAmbiguous,
    List<Color> vectorOfEnums,
    Race signedEnum,
+    List<int> testrequirednestedflatbuffer,
  })
      : _pos = pos,
        _mana = mana,
@@ -1172,7 +1179,8 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
        _anyAmbiguousType = anyAmbiguousType,
        _anyAmbiguous = anyAmbiguous,
        _vectorOfEnums = vectorOfEnums,
-        _signedEnum = signedEnum;
+        _signedEnum = signedEnum,
+        _testrequirednestedflatbuffer = testrequirednestedflatbuffer;

  /// Finish building, and store into the [fbBuilder].
  @override
@@ -1240,6 +1248,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    final int vectorOfEnumsOffset = _vectorOfEnums?.isNotEmpty == true
        ? fbBuilder.writeListUint8(_vectorOfEnums.map((f) => f.value))
        : null;
+    final int testrequirednestedflatbufferOffset = _testrequirednestedflatbuffer?.isNotEmpty == true
+        ? fbBuilder.writeListUint8(_testrequirednestedflatbuffer)
+        : null;

    fbBuilder.startTable();
    if (_pos != null) {
@@ -1342,6 +1353,9 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
      fbBuilder.addOffset(47, vectorOfEnumsOffset);
    }
    fbBuilder.addInt8(48, _signedEnum?.value);
+    if (testrequirednestedflatbufferOffset != null) {
+      fbBuilder.addOffset(49, testrequirednestedflatbufferOffset);
+    }
    return fbBuilder.endTable();
  }

--- a/tests/rust_usage_test/tests/integration_test.rs
+++ b/tests/rust_usage_test/tests/integration_test.rs
@@ -1561,7 +1561,8 @@ mod write_and_read_examples {
            vector_of_co_owning_references: None, non_owning_reference: 0, \
            vector_of_non_owning_references: None, any_unique_type: NONE, \
            any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
-            vector_of_enums: None, signed_enum: None }, test4: Some([Test { \
+            vector_of_enums: None, signed_enum: None, \
+            testrequirednestedflatbuffer: None }, test4: Some([Test { \
            a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
            testarrayofstring: Some([\"test1\", \"test2\"]), \
            testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
@@ -1578,7 +1579,8 @@ mod write_and_read_examples {
            vector_of_co_owning_references: None, non_owning_reference: 0, \
            vector_of_non_owning_references: None, any_unique_type: NONE, \
            any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
-            vector_of_enums: None, signed_enum: None }"
+            vector_of_enums: None, signed_enum: None, \
+            testrequirednestedflatbuffer: None }"
        );
    }