FlatBuffers Version 25.12.19 (#8871)

goldens/cpp/basic_generated.h

@@ -9,8 +9,8 @@
 // Ensure the included flatbuffers.h is the same version as when this file was
 // generated, otherwise it may not be compatible.
 static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 9 &&
-              FLATBUFFERS_VERSION_REVISION == 23,
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
              "Non-compatible flatbuffers version included");
 
 namespace flatbuffers {

goldens/csharp/flatbuffers/goldens/Galaxy.cs

@@ -13,7 +13,7 @@ public struct Galaxy : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_12_19(); }
   public static Galaxy GetRootAsGalaxy(ByteBuffer _bb) { return GetRootAsGalaxy(_bb, new Galaxy()); }
   public static Galaxy GetRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

goldens/csharp/flatbuffers/goldens/Universe.cs

@@ -13,7 +13,7 @@ public struct Universe : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_9_23(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_25_12_19(); }
   public static Universe GetRootAsUniverse(ByteBuffer _bb) { return GetRootAsUniverse(_bb, new Universe()); }
   public static Universe GetRootAsUniverse(ByteBuffer _bb, Universe obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool VerifyUniverse(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, UniverseVerify.Verify); }

goldens/dart/basic_flatbuffers.goldens_generated.dart

@@ -7,6 +7,7 @@ import 'dart:typed_data' show Uint8List;
 import 'package:flat_buffers/flat_buffers.dart' as fb;
 
 
+
 class Galaxy {
   Galaxy._(this._bc, this._bcOffset);
   factory Galaxy(List<int> bytes) {

goldens/java/flatbuffers/goldens/Galaxy.java

@@ -14,14 +14,13 @@ import com.google.flatbuffers.LongVector;
 import com.google.flatbuffers.ShortVector;
 import com.google.flatbuffers.StringVector;
 import com.google.flatbuffers.Struct;
-import com.google.flatbuffers.Table;
 import com.google.flatbuffers.UnionVector;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
-public final class Galaxy extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+public final class Galaxy extends com.google.flatbuffers.Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_12_19(); }
   public static Galaxy getRootAsGalaxy(ByteBuffer _bb) { return getRootAsGalaxy(_bb, new Galaxy()); }
   public static Galaxy getRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

goldens/java/flatbuffers/goldens/Universe.java

@@ -14,14 +14,13 @@ import com.google.flatbuffers.LongVector;
 import com.google.flatbuffers.ShortVector;
 import com.google.flatbuffers.StringVector;
 import com.google.flatbuffers.Struct;
-import com.google.flatbuffers.Table;
 import com.google.flatbuffers.UnionVector;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
-public final class Universe extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_25_9_23(); }
+public final class Universe extends com.google.flatbuffers.Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_25_12_19(); }
   public static Universe getRootAsUniverse(ByteBuffer _bb) { return getRootAsUniverse(_bb, new Universe()); }
   public static Universe getRootAsUniverse(ByteBuffer _bb, Universe obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

goldens/kotlin/flatbuffers/goldens/Galaxy.kt

@@ -34,7 +34,7 @@ class Galaxy : Table() {
             return if(o != 0) bb.getLong(o + bb_pos) else 0L
         }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_25_9_23()
+        fun validateVersion() = Constants.FLATBUFFERS_25_12_19()
         fun getRootAsGalaxy(_bb: ByteBuffer): Galaxy = getRootAsGalaxy(_bb, Galaxy())
         fun getRootAsGalaxy(_bb: ByteBuffer, obj: Galaxy): Galaxy {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

goldens/kotlin/flatbuffers/goldens/Universe.kt

@@ -47,7 +47,7 @@ class Universe : Table() {
             val o = __offset(6); return if (o != 0) __vector_len(o) else 0
         }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_25_9_23()
+        fun validateVersion() = Constants.FLATBUFFERS_25_12_19()
         fun getRootAsUniverse(_bb: ByteBuffer): Universe = getRootAsUniverse(_bb, Universe())
         fun getRootAsUniverse(_bb: ByteBuffer, obj: Universe): Universe {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

goldens/rust/basic_generated.rs

@@ -1,58 +1,42 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-
-
 // @generated
+extern crate alloc;
 
-use core::mem;
-use core::cmp::Ordering;
-
-extern crate flatbuffers;
-use self::flatbuffers::{EndianScalar, Follow};
 
 #[allow(unused_imports, dead_code)]
 pub mod flatbuffers {
 
-  use core::mem;
-  use core::cmp::Ordering;
-
-  extern crate flatbuffers;
-  use self::flatbuffers::{EndianScalar, Follow};
 #[allow(unused_imports, dead_code)]
 pub mod goldens {
 
-  use core::mem;
-  use core::cmp::Ordering;
-
-  extern crate flatbuffers;
-  use self::flatbuffers::{EndianScalar, Follow};
 
 pub enum GalaxyOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
 pub struct Galaxy<'a> {
-  pub _tab: flatbuffers::Table<'a>,
+  pub _tab: ::flatbuffers::Table<'a>,
 }
 
-impl<'a> flatbuffers::Follow<'a> for Galaxy<'a> {
+impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
   type Inner = Galaxy<'a>;
   #[inline]
   unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self { _tab: unsafe { flatbuffers::Table::new(buf, loc) } }
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
   }
 }
 
 impl<'a> Galaxy<'a> {
-  pub const VT_NUM_STARS: flatbuffers::VOffsetT = 4;
+  pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
 
   #[inline]
-  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
     Galaxy { _tab: table }
   }
   #[allow(unused_mut)]
-  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
-    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
     args: &'args GalaxyArgs
-  ) -> flatbuffers::WIPOffset<Galaxy<'bldr>> {
+  ) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
     let mut builder = GalaxyBuilder::new(_fbb);
     builder.add_num_stars(args.num_stars);
     builder.finish()
@@ -68,12 +52,11 @@ impl<'a> Galaxy<'a> {
   }
 }
 
-impl flatbuffers::Verifiable for Galaxy<'_> {
+impl ::flatbuffers::Verifiable for Galaxy<'_> {
   #[inline]
   fn run_verifier(
-    v: &mut flatbuffers::Verifier, pos: usize
-  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-    use self::flatbuffers::Verifiable;
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
     v.visit_table(pos)?
      .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
      .finish();
@@ -92,17 +75,17 @@ impl<'a> Default for GalaxyArgs {
   }
 }
 
-pub struct GalaxyBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
-impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
   #[inline]
   pub fn add_num_stars(&mut self, num_stars: i64) {
     self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
   }
   #[inline]
-  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
     let start = _fbb.start_table();
     GalaxyBuilder {
       fbb_: _fbb,
@@ -110,14 +93,14 @@ impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
     }
   }
   #[inline]
-  pub fn finish(self) -> flatbuffers::WIPOffset<Galaxy<'a>> {
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
     let o = self.fbb_.end_table(self.start_);
-    flatbuffers::WIPOffset::new(o.value())
+    ::flatbuffers::WIPOffset::new(o.value())
   }
 }
 
-impl core::fmt::Debug for Galaxy<'_> {
-  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+impl ::core::fmt::Debug for Galaxy<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
     let mut ds = f.debug_struct("Galaxy");
       ds.field("num_stars", &self.num_stars());
       ds.finish()
@@ -127,30 +110,30 @@ pub enum UniverseOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
 pub struct Universe<'a> {
-  pub _tab: flatbuffers::Table<'a>,
+  pub _tab: ::flatbuffers::Table<'a>,
 }
 
-impl<'a> flatbuffers::Follow<'a> for Universe<'a> {
+impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
   type Inner = Universe<'a>;
   #[inline]
   unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-    Self { _tab: unsafe { flatbuffers::Table::new(buf, loc) } }
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
   }
 }
 
 impl<'a> Universe<'a> {
-  pub const VT_AGE: flatbuffers::VOffsetT = 4;
-  pub const VT_GALAXIES: flatbuffers::VOffsetT = 6;
+  pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
+  pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
 
   #[inline]
-  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
     Universe { _tab: table }
   }
   #[allow(unused_mut)]
-  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
-    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
     args: &'args UniverseArgs<'args>
-  ) -> flatbuffers::WIPOffset<Universe<'bldr>> {
+  ) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
     let mut builder = UniverseBuilder::new(_fbb);
     builder.add_age(args.age);
     if let Some(x) = args.galaxies { builder.add_galaxies(x); }
@@ -166,30 +149,29 @@ impl<'a> Universe<'a> {
     unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
   }
   #[inline]
-  pub fn galaxies(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
+  pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
     // Safety:
     // Created from valid Table for this object
     // which contains a valid value in this slot
-    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
   }
 }
 
-impl flatbuffers::Verifiable for Universe<'_> {
+impl ::flatbuffers::Verifiable for Universe<'_> {
   #[inline]
   fn run_verifier(
-    v: &mut flatbuffers::Verifier, pos: usize
-  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
-    use self::flatbuffers::Verifiable;
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
     v.visit_table(pos)?
      .visit_field::<f64>("age", Self::VT_AGE, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
      .finish();
     Ok(())
   }
 }
 pub struct UniverseArgs<'a> {
     pub age: f64,
-    pub galaxies: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
+    pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
 }
 impl<'a> Default for UniverseArgs<'a> {
   #[inline]
@@ -201,21 +183,21 @@ impl<'a> Default for UniverseArgs<'a> {
   }
 }
 
-pub struct UniverseBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
-  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
-impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
   #[inline]
   pub fn add_age(&mut self, age: f64) {
     self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
   }
   #[inline]
-  pub fn add_galaxies(&mut self, galaxies: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
-    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
+  pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
   }
   #[inline]
-  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
     let start = _fbb.start_table();
     UniverseBuilder {
       fbb_: _fbb,
@@ -223,14 +205,14 @@ impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
     }
   }
   #[inline]
-  pub fn finish(self) -> flatbuffers::WIPOffset<Universe<'a>> {
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
     let o = self.fbb_.end_table(self.start_);
-    flatbuffers::WIPOffset::new(o.value())
+    ::flatbuffers::WIPOffset::new(o.value())
   }
 }
 
-impl core::fmt::Debug for Universe<'_> {
-  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+impl ::core::fmt::Debug for Universe<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
     let mut ds = f.debug_struct("Universe");
       ds.field("age", &self.age());
       ds.field("galaxies", &self.galaxies());
@@ -244,8 +226,8 @@ impl core::fmt::Debug for Universe<'_> {
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_universe_unchecked`.
-pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, flatbuffers::InvalidFlatbuffer> {
-  flatbuffers::root::<Universe>(buf)
+pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root::<Universe>(buf)
 }
 #[inline]
 /// Verifies that a buffer of bytes contains a size prefixed
@@ -254,8 +236,8 @@ pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, flatbuffers::Invalid
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_universe_unchecked`.
-pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, flatbuffers::InvalidFlatbuffer> {
-  flatbuffers::size_prefixed_root::<Universe>(buf)
+pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root::<Universe>(buf)
 }
 #[inline]
 /// Verifies, with the given options, that a buffer of bytes
@@ -265,10 +247,10 @@ pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, flatbu
 /// previous, unchecked, behavior use
 /// `root_as_universe_unchecked`.
 pub fn root_as_universe_with_opts<'b, 'o>(
-  opts: &'o flatbuffers::VerifierOptions,
+  opts: &'o ::flatbuffers::VerifierOptions,
   buf: &'b [u8],
-) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
-  flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
+) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
 }
 #[inline]
 /// Verifies, with the given verifier options, that a buffer of
@@ -278,34 +260,34 @@ pub fn root_as_universe_with_opts<'b, 'o>(
 /// previous, unchecked, behavior use
 /// `root_as_universe_unchecked`.
 pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
-  opts: &'o flatbuffers::VerifierOptions,
+  opts: &'o ::flatbuffers::VerifierOptions,
   buf: &'b [u8],
-) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
-  flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
+) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `Universe`.
 pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
-  unsafe { flatbuffers::root_unchecked::<Universe>(buf) }
+  unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
 pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
-  unsafe { flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
+  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
 }
 #[inline]
-pub fn finish_universe_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
-    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
-    root: flatbuffers::WIPOffset<Universe<'a>>) {
+pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    root: ::flatbuffers::WIPOffset<Universe<'a>>) {
   fbb.finish(root, None);
 }
 
 #[inline]
-pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Universe<'a>>) {
+pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Universe<'a>>) {
   fbb.finish_size_prefixed(root, None);
 }
 }  // pub mod goldens

goldens/swift/basic_generated.swift

@@ -8,9 +8,9 @@ import Common
 
 import FlatBuffers
 
-public struct flatbuffers_goldens_Galaxy: FlatBufferObject, Verifiable {
+public struct flatbuffers_goldens_Galaxy: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
 
-  static func validateVersion() { FlatBuffersVersion_25_9_23() }
+  static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
   private var _accessor: Table
 
@@ -43,9 +43,9 @@ public struct flatbuffers_goldens_Galaxy: FlatBufferObject, Verifiable {
   }
 }
 
-public struct flatbuffers_goldens_Universe: FlatBufferObject, Verifiable {
+public struct flatbuffers_goldens_Universe: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable {
 
-  static func validateVersion() { FlatBuffersVersion_25_9_23() }
+  static func validateVersion() { FlatBuffersVersion_25_12_19() }
   public var __buffer: ByteBuffer! { return _accessor.bb }
   private var _accessor: Table
 
@@ -60,9 +60,7 @@ public struct flatbuffers_goldens_Universe: FlatBufferObject, Verifiable {
   }
 
   public var age: Double { let o = _accessor.offset(VTOFFSET.age.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
-  public var hasGalaxies: Bool { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? false : true }
-  public var galaxiesCount: Int32 { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? 0 : _accessor.vector(count: o) }
-  public func galaxies(at index: Int32) -> flatbuffers_goldens_Galaxy? { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? nil : flatbuffers_goldens_Galaxy(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
+  public var galaxies: FlatbufferVector<flatbuffers_goldens_Galaxy> { return _accessor.vector(at: VTOFFSET.galaxies.v, byteSize: 4) }
   public static func startUniverse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
   public static func add(age: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: age, def: 0.0, at: VTOFFSET.age.p) }
   public static func addVectorOf(galaxies: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: galaxies, at: VTOFFSET.galaxies.p) }