@ignex/nova 0.1.1

package/src/generated/rust/backend_generated.rs

@@ -0,0 +1,2817 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+
+extern crate alloc;
+
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MIN_SIDE: i32 = 0;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MAX_SIDE: i32 = 1;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+#[allow(non_camel_case_types)]
+pub const ENUM_VALUES_SIDE: [Side; 2] = [
+  Side::BUY,
+  Side::SELL,
+];
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+pub struct Side(pub i32);
+#[allow(non_upper_case_globals)]
+impl Side {
+  pub const BUY: Self = Self(0);
+  pub const SELL: Self = Self(1);
+
+  pub const ENUM_MIN: i32 = 0;
+  pub const ENUM_MAX: i32 = 1;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::BUY,
+    Self::SELL,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::BUY => Some("BUY"),
+      Self::SELL => Some("SELL"),
+      _ => None,
+    }
+  }
+}
+impl ::core::fmt::Debug for Side {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+    }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for Side {
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
+    Self(b)
+  }
+}
+
+impl ::flatbuffers::Push for Side {
+    type Output = Side;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        unsafe { ::flatbuffers::emplace_scalar::<i32>(dst, self.0) };
+    }
+}
+
+impl ::flatbuffers::EndianScalar for Side {
+  type Scalar = i32;
+  #[inline]
+  fn to_little_endian(self) -> i32 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: i32) -> Self {
+    let b = i32::from_le(v);
+    Self(b)
+  }
+}
+
+impl<'a> ::flatbuffers::Verifiable for Side {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i32::run_verifier(v, pos)
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for Side {}
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MIN_TAGS: i32 = 0;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MAX_TAGS: i32 = 2;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+#[allow(non_camel_case_types)]
+pub const ENUM_VALUES_TAGS: [Tags; 3] = [
+  Tags::HOT,
+  Tags::NEW,
+  Tags::SALE,
+];
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+pub struct Tags(pub i32);
+#[allow(non_upper_case_globals)]
+impl Tags {
+  pub const HOT: Self = Self(0);
+  pub const NEW: Self = Self(1);
+  pub const SALE: Self = Self(2);
+
+  pub const ENUM_MIN: i32 = 0;
+  pub const ENUM_MAX: i32 = 2;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::HOT,
+    Self::NEW,
+    Self::SALE,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::HOT => Some("HOT"),
+      Self::NEW => Some("NEW"),
+      Self::SALE => Some("SALE"),
+      _ => None,
+    }
+  }
+}
+impl ::core::fmt::Debug for Tags {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+    }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for Tags {
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe { ::flatbuffers::read_scalar_at::<i32>(buf, loc) };
+    Self(b)
+  }
+}
+
+impl ::flatbuffers::Push for Tags {
+    type Output = Tags;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        unsafe { ::flatbuffers::emplace_scalar::<i32>(dst, self.0) };
+    }
+}
+
+impl ::flatbuffers::EndianScalar for Tags {
+  type Scalar = i32;
+  #[inline]
+  fn to_little_endian(self) -> i32 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: i32) -> Self {
+    let b = i32::from_le(v);
+    Self(b)
+  }
+}
+
+impl<'a> ::flatbuffers::Verifiable for Tags {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i32::run_verifier(v, pos)
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for Tags {}
+pub enum QuoteOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Quote<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Quote<'a> {
+  type Inner = Quote<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Quote<'a> {
+  pub const VT_SYMBOL: ::flatbuffers::VOffsetT = 4;
+  pub const VT_BID: ::flatbuffers::VOffsetT = 6;
+  pub const VT_ASK: ::flatbuffers::VOffsetT = 8;
+  pub const VT_BID_SIZE: ::flatbuffers::VOffsetT = 10;
+  pub const VT_ASK_SIZE: ::flatbuffers::VOffsetT = 12;
+  pub const VT_TS: ::flatbuffers::VOffsetT = 14;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Quote { _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>,
+    args: &'args QuoteArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Quote<'bldr>> {
+    let mut builder = QuoteBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.add_ask_size(args.ask_size);
+    builder.add_bid_size(args.bid_size);
+    builder.add_ask(args.ask);
+    builder.add_bid(args.bid);
+    if let Some(x) = args.symbol { builder.add_symbol(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn symbol(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Quote::VT_SYMBOL, None)}
+  }
+  #[inline]
+  pub fn bid(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Quote::VT_BID, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn ask(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Quote::VT_ASK, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn bid_size(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Quote::VT_BID_SIZE, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn ask_size(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Quote::VT_ASK_SIZE, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Quote::VT_TS, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Quote<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("symbol", Self::VT_SYMBOL, false)?
+     .visit_field::<f64>("bid", Self::VT_BID, false)?
+     .visit_field::<f64>("ask", Self::VT_ASK, false)?
+     .visit_field::<i64>("bid_size", Self::VT_BID_SIZE, false)?
+     .visit_field::<i64>("ask_size", Self::VT_ASK_SIZE, false)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct QuoteArgs<'a> {
+    pub symbol: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub bid: f64,
+    pub ask: f64,
+    pub bid_size: i64,
+    pub ask_size: i64,
+    pub ts: i64,
+}
+impl<'a> Default for QuoteArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    QuoteArgs {
+      symbol: None,
+      bid: 0.0,
+      ask: 0.0,
+      bid_size: 0,
+      ask_size: 0,
+      ts: 0,
+    }
+  }
+}
+
+pub struct QuoteBuilder<'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> QuoteBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_symbol(&mut self, symbol: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Quote::VT_SYMBOL, symbol);
+  }
+  #[inline]
+  pub fn add_bid(&mut self, bid: f64) {
+    self.fbb_.push_slot::<f64>(Quote::VT_BID, bid, 0.0);
+  }
+  #[inline]
+  pub fn add_ask(&mut self, ask: f64) {
+    self.fbb_.push_slot::<f64>(Quote::VT_ASK, ask, 0.0);
+  }
+  #[inline]
+  pub fn add_bid_size(&mut self, bid_size: i64) {
+    self.fbb_.push_slot::<i64>(Quote::VT_BID_SIZE, bid_size, 0);
+  }
+  #[inline]
+  pub fn add_ask_size(&mut self, ask_size: i64) {
+    self.fbb_.push_slot::<i64>(Quote::VT_ASK_SIZE, ask_size, 0);
+  }
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(Quote::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QuoteBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    QuoteBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Quote<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Quote<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Quote");
+      ds.field("symbol", &self.symbol());
+      ds.field("bid", &self.bid());
+      ds.field("ask", &self.ask());
+      ds.field("bid_size", &self.bid_size());
+      ds.field("ask_size", &self.ask_size());
+      ds.field("ts", &self.ts());
+      ds.finish()
+  }
+}
+pub enum TradeOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Trade<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Trade<'a> {
+  type Inner = Trade<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Trade<'a> {
+  pub const VT_SYMBOL: ::flatbuffers::VOffsetT = 4;
+  pub const VT_PRICE: ::flatbuffers::VOffsetT = 6;
+  pub const VT_VOLUME: ::flatbuffers::VOffsetT = 8;
+  pub const VT_SIDE: ::flatbuffers::VOffsetT = 10;
+  pub const VT_TS: ::flatbuffers::VOffsetT = 12;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Trade { _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>,
+    args: &'args TradeArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Trade<'bldr>> {
+    let mut builder = TradeBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.add_volume(args.volume);
+    builder.add_price(args.price);
+    builder.add_side(args.side);
+    if let Some(x) = args.symbol { builder.add_symbol(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn symbol(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Trade::VT_SYMBOL, None)}
+  }
+  #[inline]
+  pub fn price(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Trade::VT_PRICE, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn volume(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Trade::VT_VOLUME, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn side(&self) -> Side {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<Side>(Trade::VT_SIDE, Some(Side::BUY)).unwrap()}
+  }
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Trade::VT_TS, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Trade<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("symbol", Self::VT_SYMBOL, false)?
+     .visit_field::<f64>("price", Self::VT_PRICE, false)?
+     .visit_field::<i64>("volume", Self::VT_VOLUME, false)?
+     .visit_field::<Side>("side", Self::VT_SIDE, false)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct TradeArgs<'a> {
+    pub symbol: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub price: f64,
+    pub volume: i64,
+    pub side: Side,
+    pub ts: i64,
+}
+impl<'a> Default for TradeArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    TradeArgs {
+      symbol: None,
+      price: 0.0,
+      volume: 0,
+      side: Side::BUY,
+      ts: 0,
+    }
+  }
+}
+
+pub struct TradeBuilder<'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> TradeBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_symbol(&mut self, symbol: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Trade::VT_SYMBOL, symbol);
+  }
+  #[inline]
+  pub fn add_price(&mut self, price: f64) {
+    self.fbb_.push_slot::<f64>(Trade::VT_PRICE, price, 0.0);
+  }
+  #[inline]
+  pub fn add_volume(&mut self, volume: i64) {
+    self.fbb_.push_slot::<i64>(Trade::VT_VOLUME, volume, 0);
+  }
+  #[inline]
+  pub fn add_side(&mut self, side: Side) {
+    self.fbb_.push_slot::<Side>(Trade::VT_SIDE, side, Side::BUY);
+  }
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(Trade::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TradeBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    TradeBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Trade<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Trade<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Trade");
+      ds.field("symbol", &self.symbol());
+      ds.field("price", &self.price());
+      ds.field("volume", &self.volume());
+      ds.field("side", &self.side());
+      ds.field("ts", &self.ts());
+      ds.finish()
+  }
+}
+pub enum PortfolioSnapshotOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct PortfolioSnapshot<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for PortfolioSnapshot<'a> {
+  type Inner = PortfolioSnapshot<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> PortfolioSnapshot<'a> {
+  pub const VT_ACCOUNT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_POSITIONS: ::flatbuffers::VOffsetT = 6;
+  pub const VT_TOTAL_VALUE: ::flatbuffers::VOffsetT = 8;
+  pub const VT_CASH: ::flatbuffers::VOffsetT = 10;
+  pub const VT_TS: ::flatbuffers::VOffsetT = 12;
+  pub const VT_UPDATED_BY: ::flatbuffers::VOffsetT = 14;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    PortfolioSnapshot { _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>,
+    args: &'args PortfolioSnapshotArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<PortfolioSnapshot<'bldr>> {
+    let mut builder = PortfolioSnapshotBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.add_cash(args.cash);
+    builder.add_total_value(args.total_value);
+    if let Some(x) = args.updated_by { builder.add_updated_by(x); }
+    if let Some(x) = args.positions { builder.add_positions(x); }
+    if let Some(x) = args.account_id { builder.add_account_id(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn account_id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(PortfolioSnapshot::VT_ACCOUNT_ID, None)}
+  }
+  #[inline]
+  pub fn positions(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PortfolioPosition<'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<PortfolioPosition>>>>(PortfolioSnapshot::VT_POSITIONS, None)}
+  }
+  #[inline]
+  pub fn total_value(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(PortfolioSnapshot::VT_TOTAL_VALUE, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn cash(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(PortfolioSnapshot::VT_CASH, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(PortfolioSnapshot::VT_TS, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn updated_by(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(PortfolioSnapshot::VT_UPDATED_BY, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for PortfolioSnapshot<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("account_id", Self::VT_ACCOUNT_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<PortfolioPosition>>>>("positions", Self::VT_POSITIONS, false)?
+     .visit_field::<f64>("total_value", Self::VT_TOTAL_VALUE, false)?
+     .visit_field::<f64>("cash", Self::VT_CASH, false)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("updated_by", Self::VT_UPDATED_BY, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PortfolioSnapshotArgs<'a> {
+    pub account_id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub positions: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PortfolioPosition<'a>>>>>,
+    pub total_value: f64,
+    pub cash: f64,
+    pub ts: i64,
+    pub updated_by: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for PortfolioSnapshotArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    PortfolioSnapshotArgs {
+      account_id: None,
+      positions: None,
+      total_value: 0.0,
+      cash: 0.0,
+      ts: 0,
+      updated_by: None,
+    }
+  }
+}
+
+pub struct PortfolioSnapshotBuilder<'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> PortfolioSnapshotBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_account_id(&mut self, account_id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PortfolioSnapshot::VT_ACCOUNT_ID, account_id);
+  }
+  #[inline]
+  pub fn add_positions(&mut self, positions: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<PortfolioPosition<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PortfolioSnapshot::VT_POSITIONS, positions);
+  }
+  #[inline]
+  pub fn add_total_value(&mut self, total_value: f64) {
+    self.fbb_.push_slot::<f64>(PortfolioSnapshot::VT_TOTAL_VALUE, total_value, 0.0);
+  }
+  #[inline]
+  pub fn add_cash(&mut self, cash: f64) {
+    self.fbb_.push_slot::<f64>(PortfolioSnapshot::VT_CASH, cash, 0.0);
+  }
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(PortfolioSnapshot::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn add_updated_by(&mut self, updated_by: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PortfolioSnapshot::VT_UPDATED_BY, updated_by);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PortfolioSnapshotBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PortfolioSnapshotBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<PortfolioSnapshot<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for PortfolioSnapshot<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("PortfolioSnapshot");
+      ds.field("account_id", &self.account_id());
+      ds.field("positions", &self.positions());
+      ds.field("total_value", &self.total_value());
+      ds.field("cash", &self.cash());
+      ds.field("ts", &self.ts());
+      ds.field("updated_by", &self.updated_by());
+      ds.finish()
+  }
+}
+pub enum PortfolioPositionOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct PortfolioPosition<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for PortfolioPosition<'a> {
+  type Inner = PortfolioPosition<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> PortfolioPosition<'a> {
+  pub const VT_SYMBOL: ::flatbuffers::VOffsetT = 4;
+  pub const VT_QUANTITY: ::flatbuffers::VOffsetT = 6;
+  pub const VT_AVG_PRICE: ::flatbuffers::VOffsetT = 8;
+  pub const VT_PNL: ::flatbuffers::VOffsetT = 10;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    PortfolioPosition { _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>,
+    args: &'args PortfolioPositionArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<PortfolioPosition<'bldr>> {
+    let mut builder = PortfolioPositionBuilder::new(_fbb);
+    builder.add_pnl(args.pnl);
+    builder.add_avg_price(args.avg_price);
+    builder.add_quantity(args.quantity);
+    if let Some(x) = args.symbol { builder.add_symbol(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn symbol(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(PortfolioPosition::VT_SYMBOL, None)}
+  }
+  #[inline]
+  pub fn quantity(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(PortfolioPosition::VT_QUANTITY, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn avg_price(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(PortfolioPosition::VT_AVG_PRICE, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn pnl(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(PortfolioPosition::VT_PNL, Some(0.0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for PortfolioPosition<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("symbol", Self::VT_SYMBOL, false)?
+     .visit_field::<i64>("quantity", Self::VT_QUANTITY, false)?
+     .visit_field::<f64>("avg_price", Self::VT_AVG_PRICE, false)?
+     .visit_field::<f64>("pnl", Self::VT_PNL, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PortfolioPositionArgs<'a> {
+    pub symbol: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub quantity: i64,
+    pub avg_price: f64,
+    pub pnl: f64,
+}
+impl<'a> Default for PortfolioPositionArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    PortfolioPositionArgs {
+      symbol: None,
+      quantity: 0,
+      avg_price: 0.0,
+      pnl: 0.0,
+    }
+  }
+}
+
+pub struct PortfolioPositionBuilder<'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> PortfolioPositionBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_symbol(&mut self, symbol: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PortfolioPosition::VT_SYMBOL, symbol);
+  }
+  #[inline]
+  pub fn add_quantity(&mut self, quantity: i64) {
+    self.fbb_.push_slot::<i64>(PortfolioPosition::VT_QUANTITY, quantity, 0);
+  }
+  #[inline]
+  pub fn add_avg_price(&mut self, avg_price: f64) {
+    self.fbb_.push_slot::<f64>(PortfolioPosition::VT_AVG_PRICE, avg_price, 0.0);
+  }
+  #[inline]
+  pub fn add_pnl(&mut self, pnl: f64) {
+    self.fbb_.push_slot::<f64>(PortfolioPosition::VT_PNL, pnl, 0.0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PortfolioPositionBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PortfolioPositionBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<PortfolioPosition<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for PortfolioPosition<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("PortfolioPosition");
+      ds.field("symbol", &self.symbol());
+      ds.field("quantity", &self.quantity());
+      ds.field("avg_price", &self.avg_price());
+      ds.field("pnl", &self.pnl());
+      ds.finish()
+  }
+}
+pub enum ComplexOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Complex<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Complex<'a> {
+  type Inner = Complex<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Complex<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_NAMES: ::flatbuffers::VOffsetT = 6;
+  pub const VT_PRICES: ::flatbuffers::VOffsetT = 8;
+  pub const VT_COUNTS: ::flatbuffers::VOffsetT = 10;
+  pub const VT_FLAGS: ::flatbuffers::VOffsetT = 12;
+  pub const VT_TAGS: ::flatbuffers::VOffsetT = 14;
+  pub const VT_ACTIVE: ::flatbuffers::VOffsetT = 16;
+  pub const VT_TOTAL: ::flatbuffers::VOffsetT = 18;
+  pub const VT_TS: ::flatbuffers::VOffsetT = 20;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Complex { _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>,
+    args: &'args ComplexArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Complex<'bldr>> {
+    let mut builder = ComplexBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.add_total(args.total);
+    if let Some(x) = args.tags { builder.add_tags(x); }
+    if let Some(x) = args.flags { builder.add_flags(x); }
+    if let Some(x) = args.counts { builder.add_counts(x); }
+    if let Some(x) = args.prices { builder.add_prices(x); }
+    if let Some(x) = args.names { builder.add_names(x); }
+    if let Some(x) = args.id { builder.add_id(x); }
+    builder.add_active(args.active);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Complex::VT_ID, None)}
+  }
+  #[inline]
+  pub fn names(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
+    // 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<&'a str>>>>(Complex::VT_NAMES, None)}
+  }
+  #[inline]
+  pub fn prices(&self) -> Option<::flatbuffers::Vector<'a, f64>> {
+    // 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, f64>>>(Complex::VT_PRICES, None)}
+  }
+  #[inline]
+  pub fn counts(&self) -> Option<::flatbuffers::Vector<'a, i64>> {
+    // 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, i64>>>(Complex::VT_COUNTS, None)}
+  }
+  #[inline]
+  pub fn flags(&self) -> Option<::flatbuffers::Vector<'a, bool>> {
+    // 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, bool>>>(Complex::VT_FLAGS, None)}
+  }
+  #[inline]
+  pub fn tags(&self) -> Option<::flatbuffers::Vector<'a, Tags>> {
+    // 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, Tags>>>(Complex::VT_TAGS, None)}
+  }
+  #[inline]
+  pub fn active(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(Complex::VT_ACTIVE, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn total(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Complex::VT_TOTAL, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Complex::VT_TS, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Complex<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("names", Self::VT_NAMES, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("prices", Self::VT_PRICES, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, i64>>>("counts", Self::VT_COUNTS, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, bool>>>("flags", Self::VT_FLAGS, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Tags>>>("tags", Self::VT_TAGS, false)?
+     .visit_field::<bool>("active", Self::VT_ACTIVE, false)?
+     .visit_field::<f64>("total", Self::VT_TOTAL, false)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct ComplexArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub names: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
+    pub prices: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, f64>>>,
+    pub counts: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, i64>>>,
+    pub flags: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, bool>>>,
+    pub tags: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Tags>>>,
+    pub active: bool,
+    pub total: f64,
+    pub ts: i64,
+}
+impl<'a> Default for ComplexArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    ComplexArgs {
+      id: None,
+      names: None,
+      prices: None,
+      counts: None,
+      flags: None,
+      tags: None,
+      active: false,
+      total: 0.0,
+      ts: 0,
+    }
+  }
+}
+
+pub struct ComplexBuilder<'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> ComplexBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_names(&mut self, names: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_NAMES, names);
+  }
+  #[inline]
+  pub fn add_prices(&mut self, prices: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_PRICES, prices);
+  }
+  #[inline]
+  pub fn add_counts(&mut self, counts: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , i64>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_COUNTS, counts);
+  }
+  #[inline]
+  pub fn add_flags(&mut self, flags: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , bool>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_FLAGS, flags);
+  }
+  #[inline]
+  pub fn add_tags(&mut self, tags: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Tags>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Complex::VT_TAGS, tags);
+  }
+  #[inline]
+  pub fn add_active(&mut self, active: bool) {
+    self.fbb_.push_slot::<bool>(Complex::VT_ACTIVE, active, false);
+  }
+  #[inline]
+  pub fn add_total(&mut self, total: f64) {
+    self.fbb_.push_slot::<f64>(Complex::VT_TOTAL, total, 0.0);
+  }
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(Complex::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ComplexBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    ComplexBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Complex<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Complex<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Complex");
+      ds.field("id", &self.id());
+      ds.field("names", &self.names());
+      ds.field("prices", &self.prices());
+      ds.field("counts", &self.counts());
+      ds.field("flags", &self.flags());
+      ds.field("tags", &self.tags());
+      ds.field("active", &self.active());
+      ds.field("total", &self.total());
+      ds.field("ts", &self.ts());
+      ds.finish()
+  }
+}
+pub enum OrderOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Order<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Order<'a> {
+  type Inner = Order<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Order<'a> {
+  pub const VT_ORDER_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_CUSTOMER: ::flatbuffers::VOffsetT = 6;
+  pub const VT_LINES: ::flatbuffers::VOffsetT = 8;
+  pub const VT_NOTES: ::flatbuffers::VOffsetT = 10;
+  pub const VT_DISCOUNTS: ::flatbuffers::VOffsetT = 12;
+  pub const VT_ACTIVE: ::flatbuffers::VOffsetT = 14;
+  pub const VT_CREATED_AT: ::flatbuffers::VOffsetT = 16;
+  pub const VT_BILLING: ::flatbuffers::VOffsetT = 18;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Order { _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>,
+    args: &'args OrderArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Order<'bldr>> {
+    let mut builder = OrderBuilder::new(_fbb);
+    builder.add_created_at(args.created_at);
+    if let Some(x) = args.billing { builder.add_billing(x); }
+    if let Some(x) = args.discounts { builder.add_discounts(x); }
+    if let Some(x) = args.notes { builder.add_notes(x); }
+    if let Some(x) = args.lines { builder.add_lines(x); }
+    if let Some(x) = args.customer { builder.add_customer(x); }
+    if let Some(x) = args.order_id { builder.add_order_id(x); }
+    builder.add_active(args.active);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn order_id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Order::VT_ORDER_ID, None)}
+  }
+  #[inline]
+  pub fn customer(&self) -> Option<Customer<'a>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Customer>>(Order::VT_CUSTOMER, None)}
+  }
+  #[inline]
+  pub fn lines(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OrderLine<'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<OrderLine>>>>(Order::VT_LINES, None)}
+  }
+  #[inline]
+  pub fn notes(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
+    // 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<&'a str>>>>(Order::VT_NOTES, None)}
+  }
+  #[inline]
+  pub fn discounts(&self) -> Option<::flatbuffers::Vector<'a, f64>> {
+    // 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, f64>>>(Order::VT_DISCOUNTS, None)}
+  }
+  #[inline]
+  pub fn active(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(Order::VT_ACTIVE, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn created_at(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Order::VT_CREATED_AT, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn billing(&self) -> Option<OrderBilling<'a>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<OrderBilling>>(Order::VT_BILLING, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Order<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("order_id", Self::VT_ORDER_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<Customer>>("customer", Self::VT_CUSTOMER, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<OrderLine>>>>("lines", Self::VT_LINES, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("notes", Self::VT_NOTES, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, f64>>>("discounts", Self::VT_DISCOUNTS, false)?
+     .visit_field::<bool>("active", Self::VT_ACTIVE, false)?
+     .visit_field::<i64>("created_at", Self::VT_CREATED_AT, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<OrderBilling>>("billing", Self::VT_BILLING, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct OrderArgs<'a> {
+    pub order_id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub customer: Option<::flatbuffers::WIPOffset<Customer<'a>>>,
+    pub lines: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<OrderLine<'a>>>>>,
+    pub notes: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
+    pub discounts: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, f64>>>,
+    pub active: bool,
+    pub created_at: i64,
+    pub billing: Option<::flatbuffers::WIPOffset<OrderBilling<'a>>>,
+}
+impl<'a> Default for OrderArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    OrderArgs {
+      order_id: None,
+      customer: None,
+      lines: None,
+      notes: None,
+      discounts: None,
+      active: false,
+      created_at: 0,
+      billing: None,
+    }
+  }
+}
+
+pub struct OrderBuilder<'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> OrderBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_order_id(&mut self, order_id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Order::VT_ORDER_ID, order_id);
+  }
+  #[inline]
+  pub fn add_customer(&mut self, customer: ::flatbuffers::WIPOffset<Customer<'b >>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Customer>>(Order::VT_CUSTOMER, customer);
+  }
+  #[inline]
+  pub fn add_lines(&mut self, lines: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<OrderLine<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Order::VT_LINES, lines);
+  }
+  #[inline]
+  pub fn add_notes(&mut self, notes: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Order::VT_NOTES, notes);
+  }
+  #[inline]
+  pub fn add_discounts(&mut self, discounts: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , f64>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Order::VT_DISCOUNTS, discounts);
+  }
+  #[inline]
+  pub fn add_active(&mut self, active: bool) {
+    self.fbb_.push_slot::<bool>(Order::VT_ACTIVE, active, false);
+  }
+  #[inline]
+  pub fn add_created_at(&mut self, created_at: i64) {
+    self.fbb_.push_slot::<i64>(Order::VT_CREATED_AT, created_at, 0);
+  }
+  #[inline]
+  pub fn add_billing(&mut self, billing: ::flatbuffers::WIPOffset<OrderBilling<'b >>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<OrderBilling>>(Order::VT_BILLING, billing);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OrderBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    OrderBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Order<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Order<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Order");
+      ds.field("order_id", &self.order_id());
+      ds.field("customer", &self.customer());
+      ds.field("lines", &self.lines());
+      ds.field("notes", &self.notes());
+      ds.field("discounts", &self.discounts());
+      ds.field("active", &self.active());
+      ds.field("created_at", &self.created_at());
+      ds.field("billing", &self.billing());
+      ds.finish()
+  }
+}
+pub enum CustomerOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Customer<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Customer<'a> {
+  type Inner = Customer<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Customer<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_NAME: ::flatbuffers::VOffsetT = 6;
+  pub const VT_VIP: ::flatbuffers::VOffsetT = 8;
+  pub const VT_LOYALTY_POINTS: ::flatbuffers::VOffsetT = 10;
+  pub const VT_RATING: ::flatbuffers::VOffsetT = 12;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Customer { _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>,
+    args: &'args CustomerArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Customer<'bldr>> {
+    let mut builder = CustomerBuilder::new(_fbb);
+    builder.add_rating(args.rating);
+    builder.add_loyalty_points(args.loyalty_points);
+    if let Some(x) = args.name { builder.add_name(x); }
+    if let Some(x) = args.id { builder.add_id(x); }
+    builder.add_vip(args.vip);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Customer::VT_ID, None)}
+  }
+  #[inline]
+  pub fn name(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Customer::VT_NAME, None)}
+  }
+  #[inline]
+  pub fn vip(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(Customer::VT_VIP, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn loyalty_points(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Customer::VT_LOYALTY_POINTS, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn rating(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Customer::VT_RATING, Some(0.0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Customer<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<bool>("vip", Self::VT_VIP, false)?
+     .visit_field::<i64>("loyalty_points", Self::VT_LOYALTY_POINTS, false)?
+     .visit_field::<f64>("rating", Self::VT_RATING, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct CustomerArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub vip: bool,
+    pub loyalty_points: i64,
+    pub rating: f64,
+}
+impl<'a> Default for CustomerArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    CustomerArgs {
+      id: None,
+      name: None,
+      vip: false,
+      loyalty_points: 0,
+      rating: 0.0,
+    }
+  }
+}
+
+pub struct CustomerBuilder<'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> CustomerBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Customer::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Customer::VT_NAME, name);
+  }
+  #[inline]
+  pub fn add_vip(&mut self, vip: bool) {
+    self.fbb_.push_slot::<bool>(Customer::VT_VIP, vip, false);
+  }
+  #[inline]
+  pub fn add_loyalty_points(&mut self, loyalty_points: i64) {
+    self.fbb_.push_slot::<i64>(Customer::VT_LOYALTY_POINTS, loyalty_points, 0);
+  }
+  #[inline]
+  pub fn add_rating(&mut self, rating: f64) {
+    self.fbb_.push_slot::<f64>(Customer::VT_RATING, rating, 0.0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CustomerBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    CustomerBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Customer<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Customer<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Customer");
+      ds.field("id", &self.id());
+      ds.field("name", &self.name());
+      ds.field("vip", &self.vip());
+      ds.field("loyalty_points", &self.loyalty_points());
+      ds.field("rating", &self.rating());
+      ds.finish()
+  }
+}
+pub enum OrderLineOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct OrderLine<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for OrderLine<'a> {
+  type Inner = OrderLine<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> OrderLine<'a> {
+  pub const VT_SKU: ::flatbuffers::VOffsetT = 4;
+  pub const VT_QTY: ::flatbuffers::VOffsetT = 6;
+  pub const VT_UNIT_PRICE: ::flatbuffers::VOffsetT = 8;
+  pub const VT_TAGS: ::flatbuffers::VOffsetT = 10;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    OrderLine { _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>,
+    args: &'args OrderLineArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<OrderLine<'bldr>> {
+    let mut builder = OrderLineBuilder::new(_fbb);
+    builder.add_unit_price(args.unit_price);
+    builder.add_qty(args.qty);
+    if let Some(x) = args.tags { builder.add_tags(x); }
+    if let Some(x) = args.sku { builder.add_sku(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn sku(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(OrderLine::VT_SKU, None)}
+  }
+  #[inline]
+  pub fn qty(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(OrderLine::VT_QTY, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn unit_price(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(OrderLine::VT_UNIT_PRICE, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn tags(&self) -> Option<::flatbuffers::Vector<'a, Tags>> {
+    // 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, Tags>>>(OrderLine::VT_TAGS, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for OrderLine<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("sku", Self::VT_SKU, false)?
+     .visit_field::<i64>("qty", Self::VT_QTY, false)?
+     .visit_field::<f64>("unit_price", Self::VT_UNIT_PRICE, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Tags>>>("tags", Self::VT_TAGS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct OrderLineArgs<'a> {
+    pub sku: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub qty: i64,
+    pub unit_price: f64,
+    pub tags: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Tags>>>,
+}
+impl<'a> Default for OrderLineArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    OrderLineArgs {
+      sku: None,
+      qty: 0,
+      unit_price: 0.0,
+      tags: None,
+    }
+  }
+}
+
+pub struct OrderLineBuilder<'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> OrderLineBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_sku(&mut self, sku: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(OrderLine::VT_SKU, sku);
+  }
+  #[inline]
+  pub fn add_qty(&mut self, qty: i64) {
+    self.fbb_.push_slot::<i64>(OrderLine::VT_QTY, qty, 0);
+  }
+  #[inline]
+  pub fn add_unit_price(&mut self, unit_price: f64) {
+    self.fbb_.push_slot::<f64>(OrderLine::VT_UNIT_PRICE, unit_price, 0.0);
+  }
+  #[inline]
+  pub fn add_tags(&mut self, tags: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Tags>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(OrderLine::VT_TAGS, tags);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OrderLineBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    OrderLineBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<OrderLine<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for OrderLine<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("OrderLine");
+      ds.field("sku", &self.sku());
+      ds.field("qty", &self.qty());
+      ds.field("unit_price", &self.unit_price());
+      ds.field("tags", &self.tags());
+      ds.finish()
+  }
+}
+pub enum OrderBillingOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct OrderBilling<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for OrderBilling<'a> {
+  type Inner = OrderBilling<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> OrderBilling<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_NAME: ::flatbuffers::VOffsetT = 6;
+  pub const VT_VIP: ::flatbuffers::VOffsetT = 8;
+  pub const VT_LOYALTY_POINTS: ::flatbuffers::VOffsetT = 10;
+  pub const VT_RATING: ::flatbuffers::VOffsetT = 12;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    OrderBilling { _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>,
+    args: &'args OrderBillingArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<OrderBilling<'bldr>> {
+    let mut builder = OrderBillingBuilder::new(_fbb);
+    builder.add_rating(args.rating);
+    builder.add_loyalty_points(args.loyalty_points);
+    if let Some(x) = args.name { builder.add_name(x); }
+    if let Some(x) = args.id { builder.add_id(x); }
+    builder.add_vip(args.vip);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(OrderBilling::VT_ID, None)}
+  }
+  #[inline]
+  pub fn name(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(OrderBilling::VT_NAME, None)}
+  }
+  #[inline]
+  pub fn vip(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(OrderBilling::VT_VIP, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn loyalty_points(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(OrderBilling::VT_LOYALTY_POINTS, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn rating(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(OrderBilling::VT_RATING, Some(0.0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for OrderBilling<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<bool>("vip", Self::VT_VIP, false)?
+     .visit_field::<i64>("loyalty_points", Self::VT_LOYALTY_POINTS, false)?
+     .visit_field::<f64>("rating", Self::VT_RATING, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct OrderBillingArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub vip: bool,
+    pub loyalty_points: i64,
+    pub rating: f64,
+}
+impl<'a> Default for OrderBillingArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    OrderBillingArgs {
+      id: None,
+      name: None,
+      vip: false,
+      loyalty_points: 0,
+      rating: 0.0,
+    }
+  }
+}
+
+pub struct OrderBillingBuilder<'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> OrderBillingBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(OrderBilling::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(OrderBilling::VT_NAME, name);
+  }
+  #[inline]
+  pub fn add_vip(&mut self, vip: bool) {
+    self.fbb_.push_slot::<bool>(OrderBilling::VT_VIP, vip, false);
+  }
+  #[inline]
+  pub fn add_loyalty_points(&mut self, loyalty_points: i64) {
+    self.fbb_.push_slot::<i64>(OrderBilling::VT_LOYALTY_POINTS, loyalty_points, 0);
+  }
+  #[inline]
+  pub fn add_rating(&mut self, rating: f64) {
+    self.fbb_.push_slot::<f64>(OrderBilling::VT_RATING, rating, 0.0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OrderBillingBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    OrderBillingBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<OrderBilling<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for OrderBilling<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("OrderBilling");
+      ds.field("id", &self.id());
+      ds.field("name", &self.name());
+      ds.field("vip", &self.vip());
+      ds.field("loyalty_points", &self.loyalty_points());
+      ds.field("rating", &self.rating());
+      ds.finish()
+  }
+}
+pub enum BigValOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct BigVal<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for BigVal<'a> {
+  type Inner = BigVal<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> BigVal<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_SEQ: ::flatbuffers::VOffsetT = 6;
+  pub const VT_WHEN: ::flatbuffers::VOffsetT = 8;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    BigVal { _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>,
+    args: &'args BigValArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<BigVal<'bldr>> {
+    let mut builder = BigValBuilder::new(_fbb);
+    builder.add_when(args.when);
+    builder.add_seq(args.seq);
+    if let Some(x) = args.id { builder.add_id(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(BigVal::VT_ID, None)}
+  }
+  #[inline]
+  pub fn seq(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(BigVal::VT_SEQ, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn when(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(BigVal::VT_WHEN, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for BigVal<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
+     .visit_field::<i64>("seq", Self::VT_SEQ, false)?
+     .visit_field::<i64>("when", Self::VT_WHEN, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct BigValArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub seq: i64,
+    pub when: i64,
+}
+impl<'a> Default for BigValArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    BigValArgs {
+      id: None,
+      seq: 0,
+      when: 0,
+    }
+  }
+}
+
+pub struct BigValBuilder<'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> BigValBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(BigVal::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_seq(&mut self, seq: i64) {
+    self.fbb_.push_slot::<i64>(BigVal::VT_SEQ, seq, 0);
+  }
+  #[inline]
+  pub fn add_when(&mut self, when: i64) {
+    self.fbb_.push_slot::<i64>(BigVal::VT_WHEN, when, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> BigValBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    BigValBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<BigVal<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for BigVal<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("BigVal");
+      ds.field("id", &self.id());
+      ds.field("seq", &self.seq());
+      ds.field("when", &self.when());
+      ds.finish()
+  }
+}
+pub enum HelloOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Hello<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Hello<'a> {
+  type Inner = Hello<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Hello<'a> {
+  pub const VT_VERSION: ::flatbuffers::VOffsetT = 4;
+  pub const VT_CAPS: ::flatbuffers::VOffsetT = 6;
+  pub const VT_LAST_SEQ: ::flatbuffers::VOffsetT = 8;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Hello { _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>,
+    args: &'args HelloArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Hello<'bldr>> {
+    let mut builder = HelloBuilder::new(_fbb);
+    builder.add_last_seq(args.last_seq);
+    builder.add_version(args.version);
+    if let Some(x) = args.caps { builder.add_caps(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn version(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Hello::VT_VERSION, Some(0)).unwrap()}
+  }
+  #[inline]
+  pub fn caps(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
+    // 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<&'a str>>>>(Hello::VT_CAPS, None)}
+  }
+  #[inline]
+  pub fn last_seq(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Hello::VT_LAST_SEQ, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Hello<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<i64>("version", Self::VT_VERSION, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("caps", Self::VT_CAPS, false)?
+     .visit_field::<i64>("last_seq", Self::VT_LAST_SEQ, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct HelloArgs<'a> {
+    pub version: i64,
+    pub caps: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
+    pub last_seq: i64,
+}
+impl<'a> Default for HelloArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    HelloArgs {
+      version: 0,
+      caps: None,
+      last_seq: 0,
+    }
+  }
+}
+
+pub struct HelloBuilder<'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> HelloBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_version(&mut self, version: i64) {
+    self.fbb_.push_slot::<i64>(Hello::VT_VERSION, version, 0);
+  }
+  #[inline]
+  pub fn add_caps(&mut self, caps: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Hello::VT_CAPS, caps);
+  }
+  #[inline]
+  pub fn add_last_seq(&mut self, last_seq: i64) {
+    self.fbb_.push_slot::<i64>(Hello::VT_LAST_SEQ, last_seq, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> HelloBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    HelloBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Hello<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Hello<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Hello");
+      ds.field("version", &self.version());
+      ds.field("caps", &self.caps());
+      ds.field("last_seq", &self.last_seq());
+      ds.finish()
+  }
+}
+pub enum WelcomeOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Welcome<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Welcome<'a> {
+  type Inner = Welcome<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Welcome<'a> {
+  pub const VT_CLIENT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_GROUPS: ::flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Welcome { _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>,
+    args: &'args WelcomeArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Welcome<'bldr>> {
+    let mut builder = WelcomeBuilder::new(_fbb);
+    if let Some(x) = args.groups { builder.add_groups(x); }
+    if let Some(x) = args.client_id { builder.add_client_id(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn client_id(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Welcome::VT_CLIENT_ID, None)}
+  }
+  #[inline]
+  pub fn groups(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
+    // 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<&'a str>>>>(Welcome::VT_GROUPS, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Welcome<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("client_id", Self::VT_CLIENT_ID, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("groups", Self::VT_GROUPS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct WelcomeArgs<'a> {
+    pub client_id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub groups: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
+}
+impl<'a> Default for WelcomeArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    WelcomeArgs {
+      client_id: None,
+      groups: None,
+    }
+  }
+}
+
+pub struct WelcomeBuilder<'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> WelcomeBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_client_id(&mut self, client_id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Welcome::VT_CLIENT_ID, client_id);
+  }
+  #[inline]
+  pub fn add_groups(&mut self, groups: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Welcome::VT_GROUPS, groups);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WelcomeBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    WelcomeBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Welcome<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Welcome<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Welcome");
+      ds.field("client_id", &self.client_id());
+      ds.field("groups", &self.groups());
+      ds.finish()
+  }
+}
+pub enum SubscribeOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Subscribe<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Subscribe<'a> {
+  type Inner = Subscribe<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Subscribe<'a> {
+  pub const VT_TOPIC: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Subscribe { _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>,
+    args: &'args SubscribeArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Subscribe<'bldr>> {
+    let mut builder = SubscribeBuilder::new(_fbb);
+    if let Some(x) = args.topic { builder.add_topic(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn topic(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Subscribe::VT_TOPIC, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Subscribe<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("topic", Self::VT_TOPIC, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct SubscribeArgs<'a> {
+    pub topic: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for SubscribeArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    SubscribeArgs {
+      topic: None,
+    }
+  }
+}
+
+pub struct SubscribeBuilder<'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> SubscribeBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_topic(&mut self, topic: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Subscribe::VT_TOPIC, topic);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SubscribeBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    SubscribeBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Subscribe<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Subscribe<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Subscribe");
+      ds.field("topic", &self.topic());
+      ds.finish()
+  }
+}
+pub enum UnsubscribeOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Unsubscribe<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Unsubscribe<'a> {
+  type Inner = Unsubscribe<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Unsubscribe<'a> {
+  pub const VT_TOPIC: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Unsubscribe { _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>,
+    args: &'args UnsubscribeArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Unsubscribe<'bldr>> {
+    let mut builder = UnsubscribeBuilder::new(_fbb);
+    if let Some(x) = args.topic { builder.add_topic(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn topic(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Unsubscribe::VT_TOPIC, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Unsubscribe<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("topic", Self::VT_TOPIC, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct UnsubscribeArgs<'a> {
+    pub topic: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for UnsubscribeArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    UnsubscribeArgs {
+      topic: None,
+    }
+  }
+}
+
+pub struct UnsubscribeBuilder<'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> UnsubscribeBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_topic(&mut self, topic: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Unsubscribe::VT_TOPIC, topic);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UnsubscribeBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    UnsubscribeBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Unsubscribe<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Unsubscribe<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Unsubscribe");
+      ds.field("topic", &self.topic());
+      ds.finish()
+  }
+}
+pub enum JoinGroupOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct JoinGroup<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for JoinGroup<'a> {
+  type Inner = JoinGroup<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> JoinGroup<'a> {
+  pub const VT_GROUP: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    JoinGroup { _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>,
+    args: &'args JoinGroupArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<JoinGroup<'bldr>> {
+    let mut builder = JoinGroupBuilder::new(_fbb);
+    if let Some(x) = args.group { builder.add_group(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn group(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(JoinGroup::VT_GROUP, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for JoinGroup<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("group", Self::VT_GROUP, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct JoinGroupArgs<'a> {
+    pub group: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for JoinGroupArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    JoinGroupArgs {
+      group: None,
+    }
+  }
+}
+
+pub struct JoinGroupBuilder<'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> JoinGroupBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_group(&mut self, group: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(JoinGroup::VT_GROUP, group);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> JoinGroupBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    JoinGroupBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<JoinGroup<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for JoinGroup<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("JoinGroup");
+      ds.field("group", &self.group());
+      ds.finish()
+  }
+}
+pub enum LeaveGroupOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct LeaveGroup<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for LeaveGroup<'a> {
+  type Inner = LeaveGroup<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> LeaveGroup<'a> {
+  pub const VT_GROUP: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    LeaveGroup { _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>,
+    args: &'args LeaveGroupArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<LeaveGroup<'bldr>> {
+    let mut builder = LeaveGroupBuilder::new(_fbb);
+    if let Some(x) = args.group { builder.add_group(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn group(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(LeaveGroup::VT_GROUP, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for LeaveGroup<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("group", Self::VT_GROUP, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct LeaveGroupArgs<'a> {
+    pub group: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for LeaveGroupArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    LeaveGroupArgs {
+      group: None,
+    }
+  }
+}
+
+pub struct LeaveGroupBuilder<'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> LeaveGroupBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_group(&mut self, group: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(LeaveGroup::VT_GROUP, group);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> LeaveGroupBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    LeaveGroupBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<LeaveGroup<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for LeaveGroup<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("LeaveGroup");
+      ds.field("group", &self.group());
+      ds.finish()
+  }
+}
+pub enum SnapshotRequestOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct SnapshotRequest<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for SnapshotRequest<'a> {
+  type Inner = SnapshotRequest<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> SnapshotRequest<'a> {
+  pub const VT_TOPIC: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    SnapshotRequest { _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>,
+    args: &'args SnapshotRequestArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<SnapshotRequest<'bldr>> {
+    let mut builder = SnapshotRequestBuilder::new(_fbb);
+    if let Some(x) = args.topic { builder.add_topic(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn topic(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(SnapshotRequest::VT_TOPIC, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for SnapshotRequest<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("topic", Self::VT_TOPIC, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct SnapshotRequestArgs<'a> {
+    pub topic: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for SnapshotRequestArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    SnapshotRequestArgs {
+      topic: None,
+    }
+  }
+}
+
+pub struct SnapshotRequestBuilder<'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> SnapshotRequestBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_topic(&mut self, topic: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(SnapshotRequest::VT_TOPIC, topic);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SnapshotRequestBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    SnapshotRequestBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<SnapshotRequest<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for SnapshotRequest<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("SnapshotRequest");
+      ds.field("topic", &self.topic());
+      ds.finish()
+  }
+}
+pub enum PingOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Ping<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Ping<'a> {
+  type Inner = Ping<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Ping<'a> {
+  pub const VT_TS: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Ping { _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>,
+    args: &'args PingArgs
+  ) -> ::flatbuffers::WIPOffset<Ping<'bldr>> {
+    let mut builder = PingBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Ping::VT_TS, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Ping<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PingArgs {
+    pub ts: i64,
+}
+impl<'a> Default for PingArgs {
+  #[inline]
+  fn default() -> Self {
+    PingArgs {
+      ts: 0,
+    }
+  }
+}
+
+pub struct PingBuilder<'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> PingBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(Ping::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PingBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PingBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Ping<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Ping<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Ping");
+      ds.field("ts", &self.ts());
+      ds.finish()
+  }
+}
+pub enum PongOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Pong<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Pong<'a> {
+  type Inner = Pong<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Pong<'a> {
+  pub const VT_TS: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Pong { _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>,
+    args: &'args PongArgs
+  ) -> ::flatbuffers::WIPOffset<Pong<'bldr>> {
+    let mut builder = PongBuilder::new(_fbb);
+    builder.add_ts(args.ts);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn ts(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Pong::VT_TS, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Pong<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<i64>("ts", Self::VT_TS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PongArgs {
+    pub ts: i64,
+}
+impl<'a> Default for PongArgs {
+  #[inline]
+  fn default() -> Self {
+    PongArgs {
+      ts: 0,
+    }
+  }
+}
+
+pub struct PongBuilder<'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> PongBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_ts(&mut self, ts: i64) {
+    self.fbb_.push_slot::<i64>(Pong::VT_TS, ts, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PongBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PongBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Pong<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Pong<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Pong");
+      ds.field("ts", &self.ts());
+      ds.finish()
+  }
+}