flatbed 0.0.5

// automatically generated by the FlatBuffers compiler, do not modify
// @generated
extern crate alloc;


#[allow(unused_imports, dead_code)]
pub mod test {


#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SEVERITY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SEVERITY: i8 = 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_SEVERITY: [Severity; 3] = [
  Severity::Info,
  Severity::Warning,
  Severity::Error,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Severity(pub i8);
#[allow(non_upper_case_globals)]
impl Severity {
  pub const Info: Self = Self(0);
  pub const Warning: Self = Self(1);
  pub const Error: Self = Self(2);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 2;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Info,
    Self::Warning,
    Self::Error,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Info => Some("Info"),
      Self::Warning => Some("Warning"),
      Self::Error => Some("Error"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for Severity {
  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 Severity {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
    Self(b)
  }
}

impl ::flatbuffers::Push for Severity {
    type Output = Severity;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
    }
}

impl ::flatbuffers::EndianScalar for Severity {
  type Scalar = i8;
  #[inline]
  fn to_little_endian(self) -> i8 {
    self.0.to_le()
  }
  #[inline]
  #[allow(clippy::wrong_self_convention)]
  fn from_little_endian(v: i8) -> Self {
    let b = i8::from_le(v);
    Self(b)
  }
}

impl<'a> ::flatbuffers::Verifiable for Severity {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    i8::run_verifier(v, pos)
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for Severity {}
pub enum TestRequestOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct TestRequest<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for TestRequest<'a> {
  type Inner = TestRequest<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> TestRequest<'a> {
  pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 4;
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    TestRequest { _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 TestRequestArgs<'args>
  ) -> ::flatbuffers::WIPOffset<TestRequest<'bldr>> {
    let mut builder = TestRequestBuilder::new(_fbb);
    builder.add_value(args.value);
    if let Some(x) = args.message { builder.add_message(x); }
    builder.finish()
  }


  #[inline]
  pub fn message(&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>>(TestRequest::VT_MESSAGE, None)}
  }
  #[inline]
  pub fn value(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(TestRequest::VT_VALUE, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for TestRequest<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, false)?
     .visit_field::<u64>("value", Self::VT_VALUE, false)?
     .finish();
    Ok(())
  }
}
pub struct TestRequestArgs<'a> {
    pub message: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub value: u64,
}
impl<'a> Default for TestRequestArgs<'a> {
  #[inline]
  fn default() -> Self {
    TestRequestArgs {
      message: None,
      value: 0,
    }
  }
}

pub struct TestRequestBuilder<'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> TestRequestBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TestRequest::VT_MESSAGE, message);
  }
  #[inline]
  pub fn add_value(&mut self, value: u64) {
    self.fbb_.push_slot::<u64>(TestRequest::VT_VALUE, value, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TestRequestBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TestRequestBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<TestRequest<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for TestRequest<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("TestRequest");
      ds.field("message", &self.message());
      ds.field("value", &self.value());
      ds.finish()
  }
}
pub enum TestResponseOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct TestResponse<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for TestResponse<'a> {
  type Inner = TestResponse<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> TestResponse<'a> {
  pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 4;
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 6;
  pub const VT_SUCCESS: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    TestResponse { _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 TestResponseArgs<'args>
  ) -> ::flatbuffers::WIPOffset<TestResponse<'bldr>> {
    let mut builder = TestResponseBuilder::new(_fbb);
    builder.add_value(args.value);
    if let Some(x) = args.message { builder.add_message(x); }
    builder.add_success(args.success);
    builder.finish()
  }


  #[inline]
  pub fn message(&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>>(TestResponse::VT_MESSAGE, None)}
  }
  #[inline]
  pub fn value(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(TestResponse::VT_VALUE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn success(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(TestResponse::VT_SUCCESS, Some(false)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for TestResponse<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, false)?
     .visit_field::<u64>("value", Self::VT_VALUE, false)?
     .visit_field::<bool>("success", Self::VT_SUCCESS, false)?
     .finish();
    Ok(())
  }
}
pub struct TestResponseArgs<'a> {
    pub message: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub value: u64,
    pub success: bool,
}
impl<'a> Default for TestResponseArgs<'a> {
  #[inline]
  fn default() -> Self {
    TestResponseArgs {
      message: None,
      value: 0,
      success: false,
    }
  }
}

pub struct TestResponseBuilder<'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> TestResponseBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(TestResponse::VT_MESSAGE, message);
  }
  #[inline]
  pub fn add_value(&mut self, value: u64) {
    self.fbb_.push_slot::<u64>(TestResponse::VT_VALUE, value, 0);
  }
  #[inline]
  pub fn add_success(&mut self, success: bool) {
    self.fbb_.push_slot::<bool>(TestResponse::VT_SUCCESS, success, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> TestResponseBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TestResponseBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<TestResponse<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for TestResponse<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("TestResponse");
      ds.field("message", &self.message());
      ds.field("value", &self.value());
      ds.field("success", &self.success());
      ds.finish()
  }
}
pub enum AddressOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct Address<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for Address<'a> {
  type Inner = Address<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> Address<'a> {
  pub const VT_STREET: ::flatbuffers::VOffsetT = 4;
  pub const VT_CITY: ::flatbuffers::VOffsetT = 6;
  pub const VT_ZIP_CODE: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Address { _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 AddressArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Address<'bldr>> {
    let mut builder = AddressBuilder::new(_fbb);
    builder.add_zip_code(args.zip_code);
    if let Some(x) = args.city { builder.add_city(x); }
    if let Some(x) = args.street { builder.add_street(x); }
    builder.finish()
  }


  #[inline]
  pub fn street(&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>>(Address::VT_STREET, None)}
  }
  #[inline]
  pub fn city(&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>>(Address::VT_CITY, None)}
  }
  #[inline]
  pub fn zip_code(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(Address::VT_ZIP_CODE, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for Address<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("street", Self::VT_STREET, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("city", Self::VT_CITY, false)?
     .visit_field::<i32>("zip_code", Self::VT_ZIP_CODE, false)?
     .finish();
    Ok(())
  }
}
pub struct AddressArgs<'a> {
    pub street: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub city: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub zip_code: i32,
}
impl<'a> Default for AddressArgs<'a> {
  #[inline]
  fn default() -> Self {
    AddressArgs {
      street: None,
      city: None,
      zip_code: 0,
    }
  }
}

pub struct AddressBuilder<'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> AddressBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_street(&mut self, street: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Address::VT_STREET, street);
  }
  #[inline]
  pub fn add_city(&mut self, city: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Address::VT_CITY, city);
  }
  #[inline]
  pub fn add_zip_code(&mut self, zip_code: i32) {
    self.fbb_.push_slot::<i32>(Address::VT_ZIP_CODE, zip_code, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AddressBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AddressBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Address<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Address<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Address");
      ds.field("street", &self.street());
      ds.field("city", &self.city());
      ds.field("zip_code", &self.zip_code());
      ds.finish()
  }
}
pub enum UserRequestOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct UserRequest<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for UserRequest<'a> {
  type Inner = UserRequest<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> UserRequest<'a> {
  pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
  pub const VT_AGE: ::flatbuffers::VOffsetT = 6;
  pub const VT_ADDRESS: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    UserRequest { _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 UserRequestArgs<'args>
  ) -> ::flatbuffers::WIPOffset<UserRequest<'bldr>> {
    let mut builder = UserRequestBuilder::new(_fbb);
    if let Some(x) = args.address { builder.add_address(x); }
    builder.add_age(args.age);
    if let Some(x) = args.name { builder.add_name(x); }
    builder.finish()
  }


  #[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>>(UserRequest::VT_NAME, None)}
  }
  #[inline]
  pub fn age(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(UserRequest::VT_AGE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn address(&self) -> Option<Address<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Address>>(UserRequest::VT_ADDRESS, None)}
  }
}

impl ::flatbuffers::Verifiable for UserRequest<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<i32>("age", Self::VT_AGE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Address>>("address", Self::VT_ADDRESS, false)?
     .finish();
    Ok(())
  }
}
pub struct UserRequestArgs<'a> {
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub age: i32,
    pub address: Option<::flatbuffers::WIPOffset<Address<'a>>>,
}
impl<'a> Default for UserRequestArgs<'a> {
  #[inline]
  fn default() -> Self {
    UserRequestArgs {
      name: None,
      age: 0,
      address: None,
    }
  }
}

pub struct UserRequestBuilder<'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> UserRequestBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(UserRequest::VT_NAME, name);
  }
  #[inline]
  pub fn add_age(&mut self, age: i32) {
    self.fbb_.push_slot::<i32>(UserRequest::VT_AGE, age, 0);
  }
  #[inline]
  pub fn add_address(&mut self, address: ::flatbuffers::WIPOffset<Address<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Address>>(UserRequest::VT_ADDRESS, address);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UserRequestBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    UserRequestBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<UserRequest<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for UserRequest<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("UserRequest");
      ds.field("name", &self.name());
      ds.field("age", &self.age());
      ds.field("address", &self.address());
      ds.finish()
  }
}
pub enum UserResponseOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct UserResponse<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for UserResponse<'a> {
  type Inner = UserResponse<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> UserResponse<'a> {
  pub const VT_USER_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_NAME: ::flatbuffers::VOffsetT = 6;
  pub const VT_ADDRESS: ::flatbuffers::VOffsetT = 8;
  pub const VT_SUCCESS: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    UserResponse { _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 UserResponseArgs<'args>
  ) -> ::flatbuffers::WIPOffset<UserResponse<'bldr>> {
    let mut builder = UserResponseBuilder::new(_fbb);
    builder.add_user_id(args.user_id);
    if let Some(x) = args.address { builder.add_address(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_success(args.success);
    builder.finish()
  }


  #[inline]
  pub fn user_id(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(UserResponse::VT_USER_ID, Some(0)).unwrap()}
  }
  #[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>>(UserResponse::VT_NAME, None)}
  }
  #[inline]
  pub fn address(&self) -> Option<Address<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Address>>(UserResponse::VT_ADDRESS, None)}
  }
  #[inline]
  pub fn success(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(UserResponse::VT_SUCCESS, Some(false)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for UserResponse<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u64>("user_id", Self::VT_USER_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Address>>("address", Self::VT_ADDRESS, false)?
     .visit_field::<bool>("success", Self::VT_SUCCESS, false)?
     .finish();
    Ok(())
  }
}
pub struct UserResponseArgs<'a> {
    pub user_id: u64,
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub address: Option<::flatbuffers::WIPOffset<Address<'a>>>,
    pub success: bool,
}
impl<'a> Default for UserResponseArgs<'a> {
  #[inline]
  fn default() -> Self {
    UserResponseArgs {
      user_id: 0,
      name: None,
      address: None,
      success: false,
    }
  }
}

pub struct UserResponseBuilder<'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> UserResponseBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_user_id(&mut self, user_id: u64) {
    self.fbb_.push_slot::<u64>(UserResponse::VT_USER_ID, user_id, 0);
  }
  #[inline]
  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(UserResponse::VT_NAME, name);
  }
  #[inline]
  pub fn add_address(&mut self, address: ::flatbuffers::WIPOffset<Address<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Address>>(UserResponse::VT_ADDRESS, address);
  }
  #[inline]
  pub fn add_success(&mut self, success: bool) {
    self.fbb_.push_slot::<bool>(UserResponse::VT_SUCCESS, success, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UserResponseBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    UserResponseBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<UserResponse<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for UserResponse<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("UserResponse");
      ds.field("user_id", &self.user_id());
      ds.field("name", &self.name());
      ds.field("address", &self.address());
      ds.field("success", &self.success());
      ds.finish()
  }
}
pub enum AddressBookOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct AddressBook<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for AddressBook<'a> {
  type Inner = AddressBook<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> AddressBook<'a> {
  pub const VT_OWNER: ::flatbuffers::VOffsetT = 4;
  pub const VT_ADDRESSES: ::flatbuffers::VOffsetT = 6;
  pub const VT_CONTACT_NAMES: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AddressBook { _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 AddressBookArgs<'args>
  ) -> ::flatbuffers::WIPOffset<AddressBook<'bldr>> {
    let mut builder = AddressBookBuilder::new(_fbb);
    if let Some(x) = args.contact_names { builder.add_contact_names(x); }
    if let Some(x) = args.addresses { builder.add_addresses(x); }
    if let Some(x) = args.owner { builder.add_owner(x); }
    builder.finish()
  }


  #[inline]
  pub fn owner(&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>>(AddressBook::VT_OWNER, None)}
  }
  #[inline]
  pub fn addresses(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Address<'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<Address>>>>(AddressBook::VT_ADDRESSES, None)}
  }
  #[inline]
  pub fn contact_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>>>>(AddressBook::VT_CONTACT_NAMES, None)}
  }
}

impl ::flatbuffers::Verifiable for AddressBook<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("owner", Self::VT_OWNER, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Address>>>>("addresses", Self::VT_ADDRESSES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("contact_names", Self::VT_CONTACT_NAMES, false)?
     .finish();
    Ok(())
  }
}
pub struct AddressBookArgs<'a> {
    pub owner: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub addresses: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Address<'a>>>>>,
    pub contact_names: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
}
impl<'a> Default for AddressBookArgs<'a> {
  #[inline]
  fn default() -> Self {
    AddressBookArgs {
      owner: None,
      addresses: None,
      contact_names: None,
    }
  }
}

pub struct AddressBookBuilder<'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> AddressBookBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_owner(&mut self, owner: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddressBook::VT_OWNER, owner);
  }
  #[inline]
  pub fn add_addresses(&mut self, addresses: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Address<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddressBook::VT_ADDRESSES, addresses);
  }
  #[inline]
  pub fn add_contact_names(&mut self, contact_names: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddressBook::VT_CONTACT_NAMES, contact_names);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AddressBookBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AddressBookBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AddressBook<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for AddressBook<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("AddressBook");
      ds.field("owner", &self.owner());
      ds.field("addresses", &self.addresses());
      ds.field("contact_names", &self.contact_names());
      ds.finish()
  }
}
pub enum LogEventOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct LogEvent<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for LogEvent<'a> {
  type Inner = LogEvent<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> LogEvent<'a> {
  pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 4;
  pub const VT_SEVERITY: ::flatbuffers::VOffsetT = 6;
  pub const VT_HISTORY: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    LogEvent { _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 LogEventArgs<'args>
  ) -> ::flatbuffers::WIPOffset<LogEvent<'bldr>> {
    let mut builder = LogEventBuilder::new(_fbb);
    if let Some(x) = args.history { builder.add_history(x); }
    if let Some(x) = args.message { builder.add_message(x); }
    builder.add_severity(args.severity);
    builder.finish()
  }


  #[inline]
  pub fn message(&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>>(LogEvent::VT_MESSAGE, None)}
  }
  #[inline]
  pub fn severity(&self) -> Severity {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Severity>(LogEvent::VT_SEVERITY, Some(Severity::Info)).unwrap()}
  }
  #[inline]
  pub fn history(&self) -> Option<::flatbuffers::Vector<'a, Severity>> {
    // 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, Severity>>>(LogEvent::VT_HISTORY, None)}
  }
}

impl ::flatbuffers::Verifiable for LogEvent<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, false)?
     .visit_field::<Severity>("severity", Self::VT_SEVERITY, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Severity>>>("history", Self::VT_HISTORY, false)?
     .finish();
    Ok(())
  }
}
pub struct LogEventArgs<'a> {
    pub message: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub severity: Severity,
    pub history: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Severity>>>,
}
impl<'a> Default for LogEventArgs<'a> {
  #[inline]
  fn default() -> Self {
    LogEventArgs {
      message: None,
      severity: Severity::Info,
      history: None,
    }
  }
}

pub struct LogEventBuilder<'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> LogEventBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(LogEvent::VT_MESSAGE, message);
  }
  #[inline]
  pub fn add_severity(&mut self, severity: Severity) {
    self.fbb_.push_slot::<Severity>(LogEvent::VT_SEVERITY, severity, Severity::Info);
  }
  #[inline]
  pub fn add_history(&mut self, history: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Severity>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(LogEvent::VT_HISTORY, history);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> LogEventBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    LogEventBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<LogEvent<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for LogEvent<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("LogEvent");
      ds.field("message", &self.message());
      ds.field("severity", &self.severity());
      ds.field("history", &self.history());
      ds.finish()
  }
}
pub enum DefaultedOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct Defaulted<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for Defaulted<'a> {
  type Inner = Defaulted<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> Defaulted<'a> {
  pub const VT_COUNT: ::flatbuffers::VOffsetT = 4;
  pub const VT_FLAG: ::flatbuffers::VOffsetT = 6;
  pub const VT_RATIO: ::flatbuffers::VOffsetT = 8;
  pub const VT_LEVEL: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Defaulted { _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 DefaultedArgs
  ) -> ::flatbuffers::WIPOffset<Defaulted<'bldr>> {
    let mut builder = DefaultedBuilder::new(_fbb);
    builder.add_ratio(args.ratio);
    builder.add_count(args.count);
    builder.add_level(args.level);
    builder.add_flag(args.flag);
    builder.finish()
  }


  #[inline]
  pub fn count(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(Defaulted::VT_COUNT, Some(25)).unwrap()}
  }
  #[inline]
  pub fn flag(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Defaulted::VT_FLAG, Some(true)).unwrap()}
  }
  #[inline]
  pub fn ratio(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(Defaulted::VT_RATIO, Some(1.5)).unwrap()}
  }
  #[inline]
  pub fn level(&self) -> Severity {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Severity>(Defaulted::VT_LEVEL, Some(Severity::Warning)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for Defaulted<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<i32>("count", Self::VT_COUNT, false)?
     .visit_field::<bool>("flag", Self::VT_FLAG, false)?
     .visit_field::<f64>("ratio", Self::VT_RATIO, false)?
     .visit_field::<Severity>("level", Self::VT_LEVEL, false)?
     .finish();
    Ok(())
  }
}
pub struct DefaultedArgs {
    pub count: i32,
    pub flag: bool,
    pub ratio: f64,
    pub level: Severity,
}
impl<'a> Default for DefaultedArgs {
  #[inline]
  fn default() -> Self {
    DefaultedArgs {
      count: 25,
      flag: true,
      ratio: 1.5,
      level: Severity::Warning,
    }
  }
}

pub struct DefaultedBuilder<'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> DefaultedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_count(&mut self, count: i32) {
    self.fbb_.push_slot::<i32>(Defaulted::VT_COUNT, count, 25);
  }
  #[inline]
  pub fn add_flag(&mut self, flag: bool) {
    self.fbb_.push_slot::<bool>(Defaulted::VT_FLAG, flag, true);
  }
  #[inline]
  pub fn add_ratio(&mut self, ratio: f64) {
    self.fbb_.push_slot::<f64>(Defaulted::VT_RATIO, ratio, 1.5);
  }
  #[inline]
  pub fn add_level(&mut self, level: Severity) {
    self.fbb_.push_slot::<Severity>(Defaulted::VT_LEVEL, level, Severity::Warning);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> DefaultedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    DefaultedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Defaulted<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Defaulted<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Defaulted");
      ds.field("count", &self.count());
      ds.field("flag", &self.flag());
      ds.field("ratio", &self.ratio());
      ds.field("level", &self.level());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `TestRequest`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_test_request_unchecked`.
pub fn root_as_test_request(buf: &[u8]) -> Result<TestRequest<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<TestRequest>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `TestRequest` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_test_request_unchecked`.
pub fn size_prefixed_root_as_test_request(buf: &[u8]) -> Result<TestRequest<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<TestRequest>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `TestRequest` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_test_request_unchecked`.
pub fn root_as_test_request_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<TestRequest<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<TestRequest<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `TestRequest` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_test_request_unchecked`.
pub fn size_prefixed_root_as_test_request_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<TestRequest<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<TestRequest<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a TestRequest and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `TestRequest`.
pub unsafe fn root_as_test_request_unchecked(buf: &[u8]) -> TestRequest<'_> {
  unsafe { ::flatbuffers::root_unchecked::<TestRequest>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed TestRequest and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `TestRequest`.
pub unsafe fn size_prefixed_root_as_test_request_unchecked(buf: &[u8]) -> TestRequest<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<TestRequest>(buf) }
}
#[inline]
pub fn finish_test_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<TestRequest<'a>>) {
  fbb.finish(root, None);
}

#[inline]
pub fn finish_size_prefixed_test_request_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<TestRequest<'a>>) {
  fbb.finish_size_prefixed(root, None);
}
}  // pub mod test