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

use crate::bex_stream_generated::*;
use crate::bex_media_generated::*;
use crate::bex_common_generated::*;

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

  use crate::bex_stream_generated::*;
  use crate::bex_media_generated::*;
  use crate::bex_common_generated::*;
#[allow(unused_imports, dead_code)]
pub mod wire {

  use crate::bex_stream_generated::*;
  use crate::bex_media_generated::*;
  use crate::bex_common_generated::*;

pub enum HomeResultOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> HomeResult<'a> {
  pub const VT_SECTIONS: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    HomeResult { _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 HomeResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<HomeResult<'bldr>> {
    let mut builder = HomeResultBuilder::new(_fbb);
    if let Some(x) = args.sections { builder.add_sections(x); }
    builder.finish()
  }


  #[inline]
  pub fn sections(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<HomeSection<'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<HomeSection>>>>(HomeResult::VT_SECTIONS, None)}
  }
}

impl ::flatbuffers::Verifiable for HomeResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<HomeSection>>>>("sections", Self::VT_SECTIONS, false)?
     .finish();
    Ok(())
  }
}
pub struct HomeResultArgs<'a> {
    pub sections: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<HomeSection<'a>>>>>,
}
impl<'a> Default for HomeResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    HomeResultArgs {
      sections: None,
    }
  }
}

pub struct HomeResultBuilder<'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> HomeResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_sections(&mut self, sections: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<HomeSection<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeResult::VT_SECTIONS, sections);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> HomeResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    HomeResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<HomeResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> CategoryResult<'a> {
  pub const VT_RESULT: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CategoryResult { _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 CategoryResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<CategoryResult<'bldr>> {
    let mut builder = CategoryResultBuilder::new(_fbb);
    if let Some(x) = args.result { builder.add_result(x); }
    builder.finish()
  }


  #[inline]
  pub fn result(&self) -> Option<PagedResult<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PagedResult>>(CategoryResult::VT_RESULT, None)}
  }
}

impl ::flatbuffers::Verifiable for CategoryResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<PagedResult>>("result", Self::VT_RESULT, false)?
     .finish();
    Ok(())
  }
}
pub struct CategoryResultArgs<'a> {
    pub result: Option<::flatbuffers::WIPOffset<PagedResult<'a>>>,
}
impl<'a> Default for CategoryResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    CategoryResultArgs {
      result: None,
    }
  }
}

pub struct CategoryResultBuilder<'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> CategoryResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_result(&mut self, result: ::flatbuffers::WIPOffset<PagedResult<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PagedResult>>(CategoryResult::VT_RESULT, result);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CategoryResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CategoryResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CategoryResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SearchResult<'a> {
  pub const VT_RESULT: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    SearchResult { _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 SearchResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<SearchResult<'bldr>> {
    let mut builder = SearchResultBuilder::new(_fbb);
    if let Some(x) = args.result { builder.add_result(x); }
    builder.finish()
  }


  #[inline]
  pub fn result(&self) -> Option<PagedResult<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PagedResult>>(SearchResult::VT_RESULT, None)}
  }
}

impl ::flatbuffers::Verifiable for SearchResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<PagedResult>>("result", Self::VT_RESULT, false)?
     .finish();
    Ok(())
  }
}
pub struct SearchResultArgs<'a> {
    pub result: Option<::flatbuffers::WIPOffset<PagedResult<'a>>>,
}
impl<'a> Default for SearchResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    SearchResultArgs {
      result: None,
    }
  }
}

pub struct SearchResultBuilder<'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> SearchResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_result(&mut self, result: ::flatbuffers::WIPOffset<PagedResult<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PagedResult>>(SearchResult::VT_RESULT, result);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SearchResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SearchResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<SearchResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> InfoResult<'a> {
  pub const VT_INFO: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    InfoResult { _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 InfoResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<InfoResult<'bldr>> {
    let mut builder = InfoResultBuilder::new(_fbb);
    if let Some(x) = args.info { builder.add_info(x); }
    builder.finish()
  }


  #[inline]
  pub fn info(&self) -> Option<MediaInfo<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<MediaInfo>>(InfoResult::VT_INFO, None)}
  }
}

impl ::flatbuffers::Verifiable for InfoResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<MediaInfo>>("info", Self::VT_INFO, false)?
     .finish();
    Ok(())
  }
}
pub struct InfoResultArgs<'a> {
    pub info: Option<::flatbuffers::WIPOffset<MediaInfo<'a>>>,
}
impl<'a> Default for InfoResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    InfoResultArgs {
      info: None,
    }
  }
}

pub struct InfoResultBuilder<'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> InfoResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_info(&mut self, info: ::flatbuffers::WIPOffset<MediaInfo<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<MediaInfo>>(InfoResult::VT_INFO, info);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> InfoResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    InfoResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<InfoResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ServersResult<'a> {
  pub const VT_SERVERS: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ServersResult { _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 ServersResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ServersResult<'bldr>> {
    let mut builder = ServersResultBuilder::new(_fbb);
    if let Some(x) = args.servers { builder.add_servers(x); }
    builder.finish()
  }


  #[inline]
  pub fn servers(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Server<'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<Server>>>>(ServersResult::VT_SERVERS, None)}
  }
}

impl ::flatbuffers::Verifiable for ServersResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Server>>>>("servers", Self::VT_SERVERS, false)?
     .finish();
    Ok(())
  }
}
pub struct ServersResultArgs<'a> {
    pub servers: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Server<'a>>>>>,
}
impl<'a> Default for ServersResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    ServersResultArgs {
      servers: None,
    }
  }
}

pub struct ServersResultBuilder<'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> ServersResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_servers(&mut self, servers: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Server<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ServersResult::VT_SERVERS, servers);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ServersResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ServersResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ServersResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> StreamResult<'a> {
  pub const VT_SOURCE: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    StreamResult { _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 StreamResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<StreamResult<'bldr>> {
    let mut builder = StreamResultBuilder::new(_fbb);
    if let Some(x) = args.source { builder.add_source(x); }
    builder.finish()
  }


  #[inline]
  pub fn source(&self) -> Option<StreamSource<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<StreamSource>>(StreamResult::VT_SOURCE, None)}
  }
}

impl ::flatbuffers::Verifiable for StreamResult<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<StreamSource>>("source", Self::VT_SOURCE, false)?
     .finish();
    Ok(())
  }
}
pub struct StreamResultArgs<'a> {
    pub source: Option<::flatbuffers::WIPOffset<StreamSource<'a>>>,
}
impl<'a> Default for StreamResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    StreamResultArgs {
      source: None,
    }
  }
}

pub struct StreamResultBuilder<'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> StreamResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_source(&mut self, source: ::flatbuffers::WIPOffset<StreamSource<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<StreamSource>>(StreamResult::VT_SOURCE, source);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> StreamResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    StreamResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<StreamResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ErrorInfo<'a> {
  pub const VT_CODE: ::flatbuffers::VOffsetT = 4;
  pub const VT_MESSAGE: ::flatbuffers::VOffsetT = 6;
  pub const VT_PLUGIN_ID: ::flatbuffers::VOffsetT = 8;
  pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ErrorInfo { _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 ErrorInfoArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ErrorInfo<'bldr>> {
    let mut builder = ErrorInfoBuilder::new(_fbb);
    builder.add_request_id(args.request_id);
    if let Some(x) = args.plugin_id { builder.add_plugin_id(x); }
    if let Some(x) = args.message { builder.add_message(x); }
    if let Some(x) = args.code { builder.add_code(x); }
    builder.finish()
  }


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

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

pub struct ErrorInfoBuilder<'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> ErrorInfoBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_code(&mut self, code: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ErrorInfo::VT_CODE, code);
  }
  #[inline]
  pub fn add_message(&mut self, message: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ErrorInfo::VT_MESSAGE, message);
  }
  #[inline]
  pub fn add_plugin_id(&mut self, plugin_id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ErrorInfo::VT_PLUGIN_ID, plugin_id);
  }
  #[inline]
  pub fn add_request_id(&mut self, request_id: u64) {
    self.fbb_.push_slot::<u64>(ErrorInfo::VT_REQUEST_ID, request_id, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ErrorInfoBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ErrorInfoBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ErrorInfo<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for ErrorInfo<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("ErrorInfo");
      ds.field("code", &self.code());
      ds.field("message", &self.message());
      ds.field("plugin_id", &self.plugin_id());
      ds.field("request_id", &self.request_id());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `HomeResult`
/// 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_home_result_unchecked`.
pub fn root_as_home_result(buf: &[u8]) -> Result<HomeResult<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<HomeResult>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `HomeResult` 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_home_result_unchecked`.
pub fn size_prefixed_root_as_home_result(buf: &[u8]) -> Result<HomeResult<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<HomeResult>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `HomeResult` 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_home_result_unchecked`.
pub fn root_as_home_result_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<HomeResult<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<HomeResult<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `HomeResult` 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_home_result_unchecked`.
pub fn size_prefixed_root_as_home_result_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<HomeResult<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<HomeResult<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a HomeResult and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `HomeResult`.
pub unsafe fn root_as_home_result_unchecked(buf: &[u8]) -> HomeResult<'_> {
  unsafe { ::flatbuffers::root_unchecked::<HomeResult>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed HomeResult and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `HomeResult`.
pub unsafe fn size_prefixed_root_as_home_result_unchecked(buf: &[u8]) -> HomeResult<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<HomeResult>(buf) }
}
#[inline]
pub fn finish_home_result_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<HomeResult<'a>>) {
  fbb.finish(root, None);
}

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