crates/bex-wire/src/bex_common_generated.rs

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


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

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


#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MEDIA_KIND: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MEDIA_KIND: i8 = 10;
#[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_MEDIA_KIND: [MediaKind; 11] = [
  MediaKind::Movie,
  MediaKind::Series,
  MediaKind::Anime,
  MediaKind::Short,
  MediaKind::Special,
  MediaKind::Documentary,
  MediaKind::Music,
  MediaKind::Podcast,
  MediaKind::Book,
  MediaKind::Live,
  MediaKind::Unknown,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct MediaKind(pub i8);
#[allow(non_upper_case_globals)]
impl MediaKind {
  pub const Movie: Self = Self(0);
  pub const Series: Self = Self(1);
  pub const Anime: Self = Self(2);
  pub const Short: Self = Self(3);
  pub const Special: Self = Self(4);
  pub const Documentary: Self = Self(5);
  pub const Music: Self = Self(6);
  pub const Podcast: Self = Self(7);
  pub const Book: Self = Self(8);
  pub const Live: Self = Self(9);
  pub const Unknown: Self = Self(10);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 10;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Movie,
    Self::Series,
    Self::Anime,
    Self::Short,
    Self::Special,
    Self::Documentary,
    Self::Music,
    Self::Podcast,
    Self::Book,
    Self::Live,
    Self::Unknown,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Movie => Some("Movie"),
      Self::Series => Some("Series"),
      Self::Anime => Some("Anime"),
      Self::Short => Some("Short"),
      Self::Special => Some("Special"),
      Self::Documentary => Some("Documentary"),
      Self::Music => Some("Music"),
      Self::Podcast => Some("Podcast"),
      Self::Book => Some("Book"),
      Self::Live => Some("Live"),
      Self::Unknown => Some("Unknown"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for MediaKind {
  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 MediaKind {
  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 MediaKind {
    type Output = MediaKind;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
    }
}

impl ::flatbuffers::EndianScalar for MediaKind {
  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 MediaKind {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    i8::run_verifier(v, pos)
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for MediaKind {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_STATUS: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_STATUS: i8 = 5;
#[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_STATUS: [Status; 6] = [
  Status::Unknown,
  Status::Upcoming,
  Status::Ongoing,
  Status::Completed,
  Status::Cancelled,
  Status::Paused,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Status(pub i8);
#[allow(non_upper_case_globals)]
impl Status {
  pub const Unknown: Self = Self(0);
  pub const Upcoming: Self = Self(1);
  pub const Ongoing: Self = Self(2);
  pub const Completed: Self = Self(3);
  pub const Cancelled: Self = Self(4);
  pub const Paused: Self = Self(5);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 5;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Unknown,
    Self::Upcoming,
    Self::Ongoing,
    Self::Completed,
    Self::Cancelled,
    Self::Paused,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Unknown => Some("Unknown"),
      Self::Upcoming => Some("Upcoming"),
      Self::Ongoing => Some("Ongoing"),
      Self::Completed => Some("Completed"),
      Self::Cancelled => Some("Cancelled"),
      Self::Paused => Some("Paused"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for Status {
  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 Status {
  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 Status {
    type Output = Status;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
    }
}

impl ::flatbuffers::EndianScalar for Status {
  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 Status {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    i8::run_verifier(v, pos)
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for Status {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_STREAM_FORMAT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_STREAM_FORMAT: i8 = 3;
#[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_STREAM_FORMAT: [StreamFormat; 4] = [
  StreamFormat::Hls,
  StreamFormat::Dash,
  StreamFormat::Progressive,
  StreamFormat::Unknown,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct StreamFormat(pub i8);
#[allow(non_upper_case_globals)]
impl StreamFormat {
  pub const Hls: Self = Self(0);
  pub const Dash: Self = Self(1);
  pub const Progressive: Self = Self(2);
  pub const Unknown: Self = Self(3);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 3;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Hls,
    Self::Dash,
    Self::Progressive,
    Self::Unknown,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Hls => Some("Hls"),
      Self::Dash => Some("Dash"),
      Self::Progressive => Some("Progressive"),
      Self::Unknown => Some("Unknown"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for StreamFormat {
  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 StreamFormat {
  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 StreamFormat {
    type Output = StreamFormat;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
    }
}

impl ::flatbuffers::EndianScalar for StreamFormat {
  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 StreamFormat {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    i8::run_verifier(v, pos)
  }
}

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

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

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

impl<'a> Image<'a> {
  pub const VT_URL: ::flatbuffers::VOffsetT = 4;
  pub const VT_LAYOUT: ::flatbuffers::VOffsetT = 6;
  pub const VT_WIDTH: ::flatbuffers::VOffsetT = 8;
  pub const VT_HEIGHT: ::flatbuffers::VOffsetT = 10;
  pub const VT_BLURHASH: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Image { _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 ImageArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Image<'bldr>> {
    let mut builder = ImageBuilder::new(_fbb);
    if let Some(x) = args.blurhash { builder.add_blurhash(x); }
    builder.add_height(args.height);
    builder.add_width(args.width);
    if let Some(x) = args.layout { builder.add_layout(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    builder.finish()
  }


  #[inline]
  pub fn url(&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>>(Image::VT_URL, None)}
  }
  #[inline]
  pub fn layout(&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>>(Image::VT_LAYOUT, None)}
  }
  #[inline]
  pub fn width(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(Image::VT_WIDTH, Some(0)).unwrap()}
  }
  #[inline]
  pub fn height(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(Image::VT_HEIGHT, Some(0)).unwrap()}
  }
  #[inline]
  pub fn blurhash(&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>>(Image::VT_BLURHASH, None)}
  }
}

impl ::flatbuffers::Verifiable for Image<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("layout", Self::VT_LAYOUT, false)?
     .visit_field::<u32>("width", Self::VT_WIDTH, false)?
     .visit_field::<u32>("height", Self::VT_HEIGHT, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("blurhash", Self::VT_BLURHASH, false)?
     .finish();
    Ok(())
  }
}
pub struct ImageArgs<'a> {
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub layout: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub width: u32,
    pub height: u32,
    pub blurhash: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ImageArgs<'a> {
  #[inline]
  fn default() -> Self {
    ImageArgs {
      url: None,
      layout: None,
      width: 0,
      height: 0,
      blurhash: None,
    }
  }
}

pub struct ImageBuilder<'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> ImageBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Image::VT_URL, url);
  }
  #[inline]
  pub fn add_layout(&mut self, layout: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Image::VT_LAYOUT, layout);
  }
  #[inline]
  pub fn add_width(&mut self, width: u32) {
    self.fbb_.push_slot::<u32>(Image::VT_WIDTH, width, 0);
  }
  #[inline]
  pub fn add_height(&mut self, height: u32) {
    self.fbb_.push_slot::<u32>(Image::VT_HEIGHT, height, 0);
  }
  #[inline]
  pub fn add_blurhash(&mut self, blurhash: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Image::VT_BLURHASH, blurhash);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ImageBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ImageBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Image<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ImageSet<'a> {
  pub const VT_LOW: ::flatbuffers::VOffsetT = 4;
  pub const VT_MEDIUM: ::flatbuffers::VOffsetT = 6;
  pub const VT_HIGH: ::flatbuffers::VOffsetT = 8;
  pub const VT_BACKDROP: ::flatbuffers::VOffsetT = 10;
  pub const VT_LOGO: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ImageSet { _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 ImageSetArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ImageSet<'bldr>> {
    let mut builder = ImageSetBuilder::new(_fbb);
    if let Some(x) = args.logo { builder.add_logo(x); }
    if let Some(x) = args.backdrop { builder.add_backdrop(x); }
    if let Some(x) = args.high { builder.add_high(x); }
    if let Some(x) = args.medium { builder.add_medium(x); }
    if let Some(x) = args.low { builder.add_low(x); }
    builder.finish()
  }


  #[inline]
  pub fn low(&self) -> Option<Image<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Image>>(ImageSet::VT_LOW, None)}
  }
  #[inline]
  pub fn medium(&self) -> Option<Image<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Image>>(ImageSet::VT_MEDIUM, None)}
  }
  #[inline]
  pub fn high(&self) -> Option<Image<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Image>>(ImageSet::VT_HIGH, None)}
  }
  #[inline]
  pub fn backdrop(&self) -> Option<Image<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Image>>(ImageSet::VT_BACKDROP, None)}
  }
  #[inline]
  pub fn logo(&self) -> Option<Image<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Image>>(ImageSet::VT_LOGO, None)}
  }
}

impl ::flatbuffers::Verifiable for ImageSet<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("low", Self::VT_LOW, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("medium", Self::VT_MEDIUM, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("high", Self::VT_HIGH, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("backdrop", Self::VT_BACKDROP, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("logo", Self::VT_LOGO, false)?
     .finish();
    Ok(())
  }
}
pub struct ImageSetArgs<'a> {
    pub low: Option<::flatbuffers::WIPOffset<Image<'a>>>,
    pub medium: Option<::flatbuffers::WIPOffset<Image<'a>>>,
    pub high: Option<::flatbuffers::WIPOffset<Image<'a>>>,
    pub backdrop: Option<::flatbuffers::WIPOffset<Image<'a>>>,
    pub logo: Option<::flatbuffers::WIPOffset<Image<'a>>>,
}
impl<'a> Default for ImageSetArgs<'a> {
  #[inline]
  fn default() -> Self {
    ImageSetArgs {
      low: None,
      medium: None,
      high: None,
      backdrop: None,
      logo: None,
    }
  }
}

pub struct ImageSetBuilder<'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> ImageSetBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_low(&mut self, low: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(ImageSet::VT_LOW, low);
  }
  #[inline]
  pub fn add_medium(&mut self, medium: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(ImageSet::VT_MEDIUM, medium);
  }
  #[inline]
  pub fn add_high(&mut self, high: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(ImageSet::VT_HIGH, high);
  }
  #[inline]
  pub fn add_backdrop(&mut self, backdrop: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(ImageSet::VT_BACKDROP, backdrop);
  }
  #[inline]
  pub fn add_logo(&mut self, logo: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(ImageSet::VT_LOGO, logo);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ImageSetBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ImageSetBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ImageSet<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> LinkedId<'a> {
  pub const VT_SOURCE: ::flatbuffers::VOffsetT = 4;
  pub const VT_ID: ::flatbuffers::VOffsetT = 6;

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


  #[inline]
  pub fn source(&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>>(LinkedId::VT_SOURCE, None)}
  }
  #[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>>(LinkedId::VT_ID, None)}
  }
}

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

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

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

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

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

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

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


  #[inline]
  pub fn key(&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>>(Attr::VT_KEY, None)}
  }
  #[inline]
  pub fn value(&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>>(Attr::VT_VALUE, None)}
  }
}

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

pub struct AttrBuilder<'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> AttrBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Attr::VT_KEY, key);
  }
  #[inline]
  pub fn add_value(&mut self, value: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Attr::VT_VALUE, value);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AttrBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AttrBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Attr<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Attr<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Attr");
      ds.field("key", &self.key());
      ds.field("value", &self.value());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `Attr`
/// 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_attr_unchecked`.
pub fn root_as_attr(buf: &[u8]) -> Result<Attr<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<Attr>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `Attr` 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_attr_unchecked`.
pub fn size_prefixed_root_as_attr(buf: &[u8]) -> Result<Attr<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<Attr>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `Attr` 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_attr_unchecked`.
pub fn root_as_attr_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Attr<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<Attr<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `Attr` 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_attr_unchecked`.
pub fn size_prefixed_root_as_attr_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Attr<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<Attr<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a Attr and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `Attr`.
pub unsafe fn root_as_attr_unchecked(buf: &[u8]) -> Attr<'_> {
  unsafe { ::flatbuffers::root_unchecked::<Attr>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Attr and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Attr`.
pub unsafe fn size_prefixed_root_as_attr_unchecked(buf: &[u8]) -> Attr<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Attr>(buf) }
}
#[inline]
pub fn finish_attr_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<Attr<'a>>) {
  fbb.finish(root, None);
}

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