crates/bex-wire/src/bex_media_generated.rs

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

use crate::bex_common_generated::*;

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

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

  use crate::bex_common_generated::*;

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

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

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

impl<'a> MediaCard<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_KIND: ::flatbuffers::VOffsetT = 8;
  pub const VT_IMAGES: ::flatbuffers::VOffsetT = 10;
  pub const VT_ORIGINAL_TITLE: ::flatbuffers::VOffsetT = 12;
  pub const VT_TAGLINE: ::flatbuffers::VOffsetT = 14;
  pub const VT_YEAR: ::flatbuffers::VOffsetT = 16;
  pub const VT_SCORE: ::flatbuffers::VOffsetT = 18;
  pub const VT_GENRES: ::flatbuffers::VOffsetT = 20;
  pub const VT_STATUS: ::flatbuffers::VOffsetT = 22;
  pub const VT_CONTENT_RATING: ::flatbuffers::VOffsetT = 24;
  pub const VT_URL: ::flatbuffers::VOffsetT = 26;
  pub const VT_IDS: ::flatbuffers::VOffsetT = 28;
  pub const VT_EXTRA: ::flatbuffers::VOffsetT = 30;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MediaCard { _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 MediaCardArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MediaCard<'bldr>> {
    let mut builder = MediaCardBuilder::new(_fbb);
    if let Some(x) = args.extra { builder.add_extra(x); }
    if let Some(x) = args.ids { builder.add_ids(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    if let Some(x) = args.content_rating { builder.add_content_rating(x); }
    if let Some(x) = args.genres { builder.add_genres(x); }
    builder.add_score(args.score);
    if let Some(x) = args.year { builder.add_year(x); }
    if let Some(x) = args.tagline { builder.add_tagline(x); }
    if let Some(x) = args.original_title { builder.add_original_title(x); }
    if let Some(x) = args.images { builder.add_images(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.add_status(args.status);
    builder.add_kind(args.kind);
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MediaCard::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(MediaCard::VT_TITLE, None)}
  }
  #[inline]
  pub fn kind(&self) -> MediaKind {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaKind>(MediaCard::VT_KIND, Some(MediaKind::Movie)).unwrap()}
  }
  #[inline]
  pub fn images(&self) -> Option<ImageSet<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<ImageSet>>(MediaCard::VT_IMAGES, None)}
  }
  #[inline]
  pub fn original_title(&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>>(MediaCard::VT_ORIGINAL_TITLE, None)}
  }
  #[inline]
  pub fn tagline(&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>>(MediaCard::VT_TAGLINE, None)}
  }
  #[inline]
  pub fn year(&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>>(MediaCard::VT_YEAR, None)}
  }
  #[inline]
  pub fn score(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(MediaCard::VT_SCORE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn genres(&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>>>>(MediaCard::VT_GENRES, None)}
  }
  #[inline]
  pub fn status(&self) -> Status {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Status>(MediaCard::VT_STATUS, Some(Status::Unknown)).unwrap()}
  }
  #[inline]
  pub fn content_rating(&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>>(MediaCard::VT_CONTENT_RATING, None)}
  }
  #[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>>(MediaCard::VT_URL, None)}
  }
  #[inline]
  pub fn ids(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LinkedId<'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<LinkedId>>>>(MediaCard::VT_IDS, None)}
  }
  #[inline]
  pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'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<Attr>>>>(MediaCard::VT_EXTRA, None)}
  }
}

impl ::flatbuffers::Verifiable for MediaCard<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<MediaKind>("kind", Self::VT_KIND, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<ImageSet>>("images", Self::VT_IMAGES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("original_title", Self::VT_ORIGINAL_TITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("tagline", Self::VT_TAGLINE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("year", Self::VT_YEAR, false)?
     .visit_field::<u32>("score", Self::VT_SCORE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("genres", Self::VT_GENRES, false)?
     .visit_field::<Status>("status", Self::VT_STATUS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("content_rating", Self::VT_CONTENT_RATING, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<LinkedId>>>>("ids", Self::VT_IDS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Attr>>>>("extra", Self::VT_EXTRA, false)?
     .finish();
    Ok(())
  }
}
pub struct MediaCardArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub kind: MediaKind,
    pub images: Option<::flatbuffers::WIPOffset<ImageSet<'a>>>,
    pub original_title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub tagline: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub year: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub score: u32,
    pub genres: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub status: Status,
    pub content_rating: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub ids: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LinkedId<'a>>>>>,
    pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'a>>>>>,
}
impl<'a> Default for MediaCardArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaCardArgs {
      id: None,
      title: None,
      kind: MediaKind::Movie,
      images: None,
      original_title: None,
      tagline: None,
      year: None,
      score: 0,
      genres: None,
      status: Status::Unknown,
      content_rating: None,
      url: None,
      ids: None,
      extra: None,
    }
  }
}

pub struct MediaCardBuilder<'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> MediaCardBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_TITLE, title);
  }
  #[inline]
  pub fn add_kind(&mut self, kind: MediaKind) {
    self.fbb_.push_slot::<MediaKind>(MediaCard::VT_KIND, kind, MediaKind::Movie);
  }
  #[inline]
  pub fn add_images(&mut self, images: ::flatbuffers::WIPOffset<ImageSet<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<ImageSet>>(MediaCard::VT_IMAGES, images);
  }
  #[inline]
  pub fn add_original_title(&mut self, original_title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_ORIGINAL_TITLE, original_title);
  }
  #[inline]
  pub fn add_tagline(&mut self, tagline: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_TAGLINE, tagline);
  }
  #[inline]
  pub fn add_year(&mut self, year: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_YEAR, year);
  }
  #[inline]
  pub fn add_score(&mut self, score: u32) {
    self.fbb_.push_slot::<u32>(MediaCard::VT_SCORE, score, 0);
  }
  #[inline]
  pub fn add_genres(&mut self, genres: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_GENRES, genres);
  }
  #[inline]
  pub fn add_status(&mut self, status: Status) {
    self.fbb_.push_slot::<Status>(MediaCard::VT_STATUS, status, Status::Unknown);
  }
  #[inline]
  pub fn add_content_rating(&mut self, content_rating: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_CONTENT_RATING, content_rating);
  }
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_URL, url);
  }
  #[inline]
  pub fn add_ids(&mut self, ids: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<LinkedId<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_IDS, ids);
  }
  #[inline]
  pub fn add_extra(&mut self, extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Attr<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCard::VT_EXTRA, extra);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MediaCardBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaCardBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MediaCard<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for MediaCard<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MediaCard");
      ds.field("id", &self.id());
      ds.field("title", &self.title());
      ds.field("kind", &self.kind());
      ds.field("images", &self.images());
      ds.field("original_title", &self.original_title());
      ds.field("tagline", &self.tagline());
      ds.field("year", &self.year());
      ds.field("score", &self.score());
      ds.field("genres", &self.genres());
      ds.field("status", &self.status());
      ds.field("content_rating", &self.content_rating());
      ds.field("url", &self.url());
      ds.field("ids", &self.ids());
      ds.field("extra", &self.extra());
      ds.finish()
  }
}
pub enum CategoryLinkOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> CategoryLink<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_SUBTITLE: ::flatbuffers::VOffsetT = 8;
  pub const VT_IMAGE: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CategoryLink { _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 CategoryLinkArgs<'args>
  ) -> ::flatbuffers::WIPOffset<CategoryLink<'bldr>> {
    let mut builder = CategoryLinkBuilder::new(_fbb);
    if let Some(x) = args.image { builder.add_image(x); }
    if let Some(x) = args.subtitle { builder.add_subtitle(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(CategoryLink::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(CategoryLink::VT_TITLE, None)}
  }
  #[inline]
  pub fn subtitle(&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>>(CategoryLink::VT_SUBTITLE, None)}
  }
  #[inline]
  pub fn image(&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>>(CategoryLink::VT_IMAGE, None)}
  }
}

impl ::flatbuffers::Verifiable for CategoryLink<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("subtitle", Self::VT_SUBTITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Image>>("image", Self::VT_IMAGE, false)?
     .finish();
    Ok(())
  }
}
pub struct CategoryLinkArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub subtitle: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub image: Option<::flatbuffers::WIPOffset<Image<'a>>>,
}
impl<'a> Default for CategoryLinkArgs<'a> {
  #[inline]
  fn default() -> Self {
    CategoryLinkArgs {
      id: None,
      title: None,
      subtitle: None,
      image: None,
    }
  }
}

pub struct CategoryLinkBuilder<'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> CategoryLinkBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(CategoryLink::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(CategoryLink::VT_TITLE, title);
  }
  #[inline]
  pub fn add_subtitle(&mut self, subtitle: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(CategoryLink::VT_SUBTITLE, subtitle);
  }
  #[inline]
  pub fn add_image(&mut self, image: ::flatbuffers::WIPOffset<Image<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Image>>(CategoryLink::VT_IMAGE, image);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CategoryLinkBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CategoryLinkBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CategoryLink<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> HomeSection<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_SUBTITLE: ::flatbuffers::VOffsetT = 8;
  pub const VT_ITEMS: ::flatbuffers::VOffsetT = 10;
  pub const VT_NEXT_PAGE: ::flatbuffers::VOffsetT = 12;
  pub const VT_LAYOUT: ::flatbuffers::VOffsetT = 14;
  pub const VT_SHOW_RANK: ::flatbuffers::VOffsetT = 16;
  pub const VT_CATEGORIES: ::flatbuffers::VOffsetT = 18;
  pub const VT_EXTRA: ::flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    HomeSection { _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 HomeSectionArgs<'args>
  ) -> ::flatbuffers::WIPOffset<HomeSection<'bldr>> {
    let mut builder = HomeSectionBuilder::new(_fbb);
    if let Some(x) = args.extra { builder.add_extra(x); }
    if let Some(x) = args.categories { builder.add_categories(x); }
    if let Some(x) = args.layout { builder.add_layout(x); }
    if let Some(x) = args.next_page { builder.add_next_page(x); }
    if let Some(x) = args.items { builder.add_items(x); }
    if let Some(x) = args.subtitle { builder.add_subtitle(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.add_show_rank(args.show_rank);
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(HomeSection::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(HomeSection::VT_TITLE, None)}
  }
  #[inline]
  pub fn subtitle(&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>>(HomeSection::VT_SUBTITLE, None)}
  }
  #[inline]
  pub fn items(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaCard<'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<MediaCard>>>>(HomeSection::VT_ITEMS, None)}
  }
  #[inline]
  pub fn next_page(&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>>(HomeSection::VT_NEXT_PAGE, 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>>(HomeSection::VT_LAYOUT, None)}
  }
  #[inline]
  pub fn show_rank(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(HomeSection::VT_SHOW_RANK, Some(false)).unwrap()}
  }
  #[inline]
  pub fn categories(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CategoryLink<'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<CategoryLink>>>>(HomeSection::VT_CATEGORIES, None)}
  }
  #[inline]
  pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'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<Attr>>>>(HomeSection::VT_EXTRA, None)}
  }
}

impl ::flatbuffers::Verifiable for HomeSection<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("subtitle", Self::VT_SUBTITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MediaCard>>>>("items", Self::VT_ITEMS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("next_page", Self::VT_NEXT_PAGE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("layout", Self::VT_LAYOUT, false)?
     .visit_field::<bool>("show_rank", Self::VT_SHOW_RANK, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<CategoryLink>>>>("categories", Self::VT_CATEGORIES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Attr>>>>("extra", Self::VT_EXTRA, false)?
     .finish();
    Ok(())
  }
}
pub struct HomeSectionArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub subtitle: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub items: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaCard<'a>>>>>,
    pub next_page: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub layout: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub show_rank: bool,
    pub categories: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CategoryLink<'a>>>>>,
    pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'a>>>>>,
}
impl<'a> Default for HomeSectionArgs<'a> {
  #[inline]
  fn default() -> Self {
    HomeSectionArgs {
      id: None,
      title: None,
      subtitle: None,
      items: None,
      next_page: None,
      layout: None,
      show_rank: false,
      categories: None,
      extra: None,
    }
  }
}

pub struct HomeSectionBuilder<'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> HomeSectionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_TITLE, title);
  }
  #[inline]
  pub fn add_subtitle(&mut self, subtitle: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_SUBTITLE, subtitle);
  }
  #[inline]
  pub fn add_items(&mut self, items: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<MediaCard<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_ITEMS, items);
  }
  #[inline]
  pub fn add_next_page(&mut self, next_page: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_NEXT_PAGE, next_page);
  }
  #[inline]
  pub fn add_layout(&mut self, layout: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_LAYOUT, layout);
  }
  #[inline]
  pub fn add_show_rank(&mut self, show_rank: bool) {
    self.fbb_.push_slot::<bool>(HomeSection::VT_SHOW_RANK, show_rank, false);
  }
  #[inline]
  pub fn add_categories(&mut self, categories: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<CategoryLink<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_CATEGORIES, categories);
  }
  #[inline]
  pub fn add_extra(&mut self, extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Attr<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(HomeSection::VT_EXTRA, extra);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> HomeSectionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    HomeSectionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<HomeSection<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for HomeSection<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("HomeSection");
      ds.field("id", &self.id());
      ds.field("title", &self.title());
      ds.field("subtitle", &self.subtitle());
      ds.field("items", &self.items());
      ds.field("next_page", &self.next_page());
      ds.field("layout", &self.layout());
      ds.field("show_rank", &self.show_rank());
      ds.field("categories", &self.categories());
      ds.field("extra", &self.extra());
      ds.finish()
  }
}
pub enum PagedResultOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> PagedResult<'a> {
  pub const VT_ITEMS: ::flatbuffers::VOffsetT = 4;
  pub const VT_CATEGORIES: ::flatbuffers::VOffsetT = 6;
  pub const VT_NEXT_PAGE: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    PagedResult { _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 PagedResultArgs<'args>
  ) -> ::flatbuffers::WIPOffset<PagedResult<'bldr>> {
    let mut builder = PagedResultBuilder::new(_fbb);
    if let Some(x) = args.next_page { builder.add_next_page(x); }
    if let Some(x) = args.categories { builder.add_categories(x); }
    if let Some(x) = args.items { builder.add_items(x); }
    builder.finish()
  }


  #[inline]
  pub fn items(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaCard<'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<MediaCard>>>>(PagedResult::VT_ITEMS, None)}
  }
  #[inline]
  pub fn categories(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CategoryLink<'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<CategoryLink>>>>(PagedResult::VT_CATEGORIES, None)}
  }
  #[inline]
  pub fn next_page(&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>>(PagedResult::VT_NEXT_PAGE, None)}
  }
}

impl ::flatbuffers::Verifiable for PagedResult<'_> {
  #[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<MediaCard>>>>("items", Self::VT_ITEMS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<CategoryLink>>>>("categories", Self::VT_CATEGORIES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("next_page", Self::VT_NEXT_PAGE, false)?
     .finish();
    Ok(())
  }
}
pub struct PagedResultArgs<'a> {
    pub items: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaCard<'a>>>>>,
    pub categories: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CategoryLink<'a>>>>>,
    pub next_page: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for PagedResultArgs<'a> {
  #[inline]
  fn default() -> Self {
    PagedResultArgs {
      items: None,
      categories: None,
      next_page: None,
    }
  }
}

pub struct PagedResultBuilder<'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> PagedResultBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_items(&mut self, items: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<MediaCard<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PagedResult::VT_ITEMS, items);
  }
  #[inline]
  pub fn add_categories(&mut self, categories: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<CategoryLink<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PagedResult::VT_CATEGORIES, categories);
  }
  #[inline]
  pub fn add_next_page(&mut self, next_page: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PagedResult::VT_NEXT_PAGE, next_page);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PagedResultBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PagedResultBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<PagedResult<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Episode<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_NUMBER: ::flatbuffers::VOffsetT = 8;
  pub const VT_SEASON: ::flatbuffers::VOffsetT = 10;
  pub const VT_IMAGES: ::flatbuffers::VOffsetT = 12;
  pub const VT_DESCRIPTION: ::flatbuffers::VOffsetT = 14;
  pub const VT_RELEASED: ::flatbuffers::VOffsetT = 16;
  pub const VT_SCORE: ::flatbuffers::VOffsetT = 18;
  pub const VT_URL: ::flatbuffers::VOffsetT = 20;
  pub const VT_TAGS: ::flatbuffers::VOffsetT = 22;
  pub const VT_EXTRA: ::flatbuffers::VOffsetT = 24;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Episode { _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 EpisodeArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Episode<'bldr>> {
    let mut builder = EpisodeBuilder::new(_fbb);
    builder.add_season(args.season);
    builder.add_number(args.number);
    if let Some(x) = args.extra { builder.add_extra(x); }
    if let Some(x) = args.tags { builder.add_tags(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    builder.add_score(args.score);
    if let Some(x) = args.released { builder.add_released(x); }
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.images { builder.add_images(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Episode::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(Episode::VT_TITLE, None)}
  }
  #[inline]
  pub fn number(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(Episode::VT_NUMBER, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn season(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(Episode::VT_SEASON, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn images(&self) -> Option<ImageSet<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<ImageSet>>(Episode::VT_IMAGES, None)}
  }
  #[inline]
  pub fn description(&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>>(Episode::VT_DESCRIPTION, None)}
  }
  #[inline]
  pub fn released(&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>>(Episode::VT_RELEASED, None)}
  }
  #[inline]
  pub fn score(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(Episode::VT_SCORE, Some(0)).unwrap()}
  }
  #[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>>(Episode::VT_URL, None)}
  }
  #[inline]
  pub fn tags(&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>>>>(Episode::VT_TAGS, None)}
  }
  #[inline]
  pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'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<Attr>>>>(Episode::VT_EXTRA, None)}
  }
}

impl ::flatbuffers::Verifiable for Episode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<f64>("number", Self::VT_NUMBER, false)?
     .visit_field::<f64>("season", Self::VT_SEASON, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<ImageSet>>("images", Self::VT_IMAGES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("released", Self::VT_RELEASED, false)?
     .visit_field::<u32>("score", Self::VT_SCORE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("tags", Self::VT_TAGS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Attr>>>>("extra", Self::VT_EXTRA, false)?
     .finish();
    Ok(())
  }
}
pub struct EpisodeArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub number: f64,
    pub season: f64,
    pub images: Option<::flatbuffers::WIPOffset<ImageSet<'a>>>,
    pub description: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub released: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub score: u32,
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub tags: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'a>>>>>,
}
impl<'a> Default for EpisodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    EpisodeArgs {
      id: None,
      title: None,
      number: 0.0,
      season: 0.0,
      images: None,
      description: None,
      released: None,
      score: 0,
      url: None,
      tags: None,
      extra: None,
    }
  }
}

pub struct EpisodeBuilder<'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> EpisodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_TITLE, title);
  }
  #[inline]
  pub fn add_number(&mut self, number: f64) {
    self.fbb_.push_slot::<f64>(Episode::VT_NUMBER, number, 0.0);
  }
  #[inline]
  pub fn add_season(&mut self, season: f64) {
    self.fbb_.push_slot::<f64>(Episode::VT_SEASON, season, 0.0);
  }
  #[inline]
  pub fn add_images(&mut self, images: ::flatbuffers::WIPOffset<ImageSet<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<ImageSet>>(Episode::VT_IMAGES, images);
  }
  #[inline]
  pub fn add_description(&mut self, description: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_released(&mut self, released: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_RELEASED, released);
  }
  #[inline]
  pub fn add_score(&mut self, score: u32) {
    self.fbb_.push_slot::<u32>(Episode::VT_SCORE, score, 0);
  }
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_URL, url);
  }
  #[inline]
  pub fn add_tags(&mut self, tags: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_TAGS, tags);
  }
  #[inline]
  pub fn add_extra(&mut self, extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Attr<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Episode::VT_EXTRA, extra);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> EpisodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    EpisodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Episode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Episode<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Episode");
      ds.field("id", &self.id());
      ds.field("title", &self.title());
      ds.field("number", &self.number());
      ds.field("season", &self.season());
      ds.field("images", &self.images());
      ds.field("description", &self.description());
      ds.field("released", &self.released());
      ds.field("score", &self.score());
      ds.field("url", &self.url());
      ds.field("tags", &self.tags());
      ds.field("extra", &self.extra());
      ds.finish()
  }
}
pub enum SeasonOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> Season<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_NUMBER: ::flatbuffers::VOffsetT = 8;
  pub const VT_YEAR: ::flatbuffers::VOffsetT = 10;
  pub const VT_EPISODES: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Season { _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 SeasonArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Season<'bldr>> {
    let mut builder = SeasonBuilder::new(_fbb);
    builder.add_number(args.number);
    if let Some(x) = args.episodes { builder.add_episodes(x); }
    builder.add_year(args.year);
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Season::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(Season::VT_TITLE, None)}
  }
  #[inline]
  pub fn number(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(Season::VT_NUMBER, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn year(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(Season::VT_YEAR, Some(0)).unwrap()}
  }
  #[inline]
  pub fn episodes(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Episode<'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<Episode>>>>(Season::VT_EPISODES, None)}
  }
}

impl ::flatbuffers::Verifiable for Season<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<f64>("number", Self::VT_NUMBER, false)?
     .visit_field::<u32>("year", Self::VT_YEAR, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Episode>>>>("episodes", Self::VT_EPISODES, false)?
     .finish();
    Ok(())
  }
}
pub struct SeasonArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub number: f64,
    pub year: u32,
    pub episodes: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Episode<'a>>>>>,
}
impl<'a> Default for SeasonArgs<'a> {
  #[inline]
  fn default() -> Self {
    SeasonArgs {
      id: None,
      title: None,
      number: 0.0,
      year: 0,
      episodes: None,
    }
  }
}

pub struct SeasonBuilder<'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> SeasonBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Season::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Season::VT_TITLE, title);
  }
  #[inline]
  pub fn add_number(&mut self, number: f64) {
    self.fbb_.push_slot::<f64>(Season::VT_NUMBER, number, 0.0);
  }
  #[inline]
  pub fn add_year(&mut self, year: u32) {
    self.fbb_.push_slot::<u32>(Season::VT_YEAR, year, 0);
  }
  #[inline]
  pub fn add_episodes(&mut self, episodes: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Episode<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Season::VT_EPISODES, episodes);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SeasonBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SeasonBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Season<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Person<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_NAME: ::flatbuffers::VOffsetT = 6;
  pub const VT_IMAGE: ::flatbuffers::VOffsetT = 8;
  pub const VT_ROLE: ::flatbuffers::VOffsetT = 10;
  pub const VT_URL: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Person { _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 PersonArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Person<'bldr>> {
    let mut builder = PersonBuilder::new(_fbb);
    if let Some(x) = args.url { builder.add_url(x); }
    if let Some(x) = args.role { builder.add_role(x); }
    if let Some(x) = args.image { builder.add_image(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Person::VT_ID, None)}
  }
  #[inline]
  pub fn name(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Person::VT_NAME, None)}
  }
  #[inline]
  pub fn image(&self) -> Option<ImageSet<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<ImageSet>>(Person::VT_IMAGE, None)}
  }
  #[inline]
  pub fn role(&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>>(Person::VT_ROLE, None)}
  }
  #[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>>(Person::VT_URL, None)}
  }
}

impl ::flatbuffers::Verifiable for Person<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<ImageSet>>("image", Self::VT_IMAGE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("role", Self::VT_ROLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .finish();
    Ok(())
  }
}
pub struct PersonArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub image: Option<::flatbuffers::WIPOffset<ImageSet<'a>>>,
    pub role: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for PersonArgs<'a> {
  #[inline]
  fn default() -> Self {
    PersonArgs {
      id: None,
      name: None,
      image: None,
      role: None,
      url: None,
    }
  }
}

pub struct PersonBuilder<'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> PersonBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Person::VT_ID, id);
  }
  #[inline]
  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Person::VT_NAME, name);
  }
  #[inline]
  pub fn add_image(&mut self, image: ::flatbuffers::WIPOffset<ImageSet<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<ImageSet>>(Person::VT_IMAGE, image);
  }
  #[inline]
  pub fn add_role(&mut self, role: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Person::VT_ROLE, role);
  }
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Person::VT_URL, url);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PersonBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PersonBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Person<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> MediaInfo<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 6;
  pub const VT_KIND: ::flatbuffers::VOffsetT = 8;
  pub const VT_IMAGES: ::flatbuffers::VOffsetT = 10;
  pub const VT_ORIGINAL_TITLE: ::flatbuffers::VOffsetT = 12;
  pub const VT_DESCRIPTION: ::flatbuffers::VOffsetT = 14;
  pub const VT_SCORE: ::flatbuffers::VOffsetT = 16;
  pub const VT_SCORED_BY: ::flatbuffers::VOffsetT = 18;
  pub const VT_YEAR: ::flatbuffers::VOffsetT = 20;
  pub const VT_RELEASE_DATE: ::flatbuffers::VOffsetT = 22;
  pub const VT_GENRES: ::flatbuffers::VOffsetT = 24;
  pub const VT_TAGS: ::flatbuffers::VOffsetT = 26;
  pub const VT_STATUS: ::flatbuffers::VOffsetT = 28;
  pub const VT_CONTENT_RATING: ::flatbuffers::VOffsetT = 30;
  pub const VT_SEASONS: ::flatbuffers::VOffsetT = 32;
  pub const VT_CAST: ::flatbuffers::VOffsetT = 34;
  pub const VT_CREW: ::flatbuffers::VOffsetT = 36;
  pub const VT_RUNTIME_MINUTES: ::flatbuffers::VOffsetT = 38;
  pub const VT_TRAILER_URL: ::flatbuffers::VOffsetT = 40;
  pub const VT_IDS: ::flatbuffers::VOffsetT = 42;
  pub const VT_STUDIO: ::flatbuffers::VOffsetT = 44;
  pub const VT_COUNTRY: ::flatbuffers::VOffsetT = 46;
  pub const VT_LANGUAGE: ::flatbuffers::VOffsetT = 48;
  pub const VT_URL: ::flatbuffers::VOffsetT = 50;
  pub const VT_EXTRA: ::flatbuffers::VOffsetT = 52;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MediaInfo { _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 MediaInfoArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MediaInfo<'bldr>> {
    let mut builder = MediaInfoBuilder::new(_fbb);
    builder.add_scored_by(args.scored_by);
    if let Some(x) = args.extra { builder.add_extra(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    if let Some(x) = args.language { builder.add_language(x); }
    if let Some(x) = args.country { builder.add_country(x); }
    if let Some(x) = args.studio { builder.add_studio(x); }
    if let Some(x) = args.ids { builder.add_ids(x); }
    if let Some(x) = args.trailer_url { builder.add_trailer_url(x); }
    builder.add_runtime_minutes(args.runtime_minutes);
    if let Some(x) = args.crew { builder.add_crew(x); }
    if let Some(x) = args.cast { builder.add_cast(x); }
    if let Some(x) = args.seasons { builder.add_seasons(x); }
    if let Some(x) = args.content_rating { builder.add_content_rating(x); }
    if let Some(x) = args.tags { builder.add_tags(x); }
    if let Some(x) = args.genres { builder.add_genres(x); }
    if let Some(x) = args.release_date { builder.add_release_date(x); }
    if let Some(x) = args.year { builder.add_year(x); }
    builder.add_score(args.score);
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.original_title { builder.add_original_title(x); }
    if let Some(x) = args.images { builder.add_images(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.add_status(args.status);
    builder.add_kind(args.kind);
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(MediaInfo::VT_ID, None)}
  }
  #[inline]
  pub fn title(&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>>(MediaInfo::VT_TITLE, None)}
  }
  #[inline]
  pub fn kind(&self) -> MediaKind {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaKind>(MediaInfo::VT_KIND, Some(MediaKind::Movie)).unwrap()}
  }
  #[inline]
  pub fn images(&self) -> Option<ImageSet<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<ImageSet>>(MediaInfo::VT_IMAGES, None)}
  }
  #[inline]
  pub fn original_title(&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>>(MediaInfo::VT_ORIGINAL_TITLE, None)}
  }
  #[inline]
  pub fn description(&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>>(MediaInfo::VT_DESCRIPTION, None)}
  }
  #[inline]
  pub fn score(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(MediaInfo::VT_SCORE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn scored_by(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(MediaInfo::VT_SCORED_BY, Some(0)).unwrap()}
  }
  #[inline]
  pub fn year(&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>>(MediaInfo::VT_YEAR, None)}
  }
  #[inline]
  pub fn release_date(&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>>(MediaInfo::VT_RELEASE_DATE, None)}
  }
  #[inline]
  pub fn genres(&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>>>>(MediaInfo::VT_GENRES, None)}
  }
  #[inline]
  pub fn tags(&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>>>>(MediaInfo::VT_TAGS, None)}
  }
  #[inline]
  pub fn status(&self) -> Status {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Status>(MediaInfo::VT_STATUS, Some(Status::Unknown)).unwrap()}
  }
  #[inline]
  pub fn content_rating(&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>>(MediaInfo::VT_CONTENT_RATING, None)}
  }
  #[inline]
  pub fn seasons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Season<'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<Season>>>>(MediaInfo::VT_SEASONS, None)}
  }
  #[inline]
  pub fn cast(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Person<'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<Person>>>>(MediaInfo::VT_CAST, None)}
  }
  #[inline]
  pub fn crew(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Person<'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<Person>>>>(MediaInfo::VT_CREW, None)}
  }
  #[inline]
  pub fn runtime_minutes(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(MediaInfo::VT_RUNTIME_MINUTES, Some(0)).unwrap()}
  }
  #[inline]
  pub fn trailer_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>>(MediaInfo::VT_TRAILER_URL, None)}
  }
  #[inline]
  pub fn ids(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LinkedId<'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<LinkedId>>>>(MediaInfo::VT_IDS, None)}
  }
  #[inline]
  pub fn studio(&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>>(MediaInfo::VT_STUDIO, None)}
  }
  #[inline]
  pub fn country(&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>>(MediaInfo::VT_COUNTRY, None)}
  }
  #[inline]
  pub fn language(&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>>(MediaInfo::VT_LANGUAGE, None)}
  }
  #[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>>(MediaInfo::VT_URL, None)}
  }
  #[inline]
  pub fn extra(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'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<Attr>>>>(MediaInfo::VT_EXTRA, None)}
  }
}

impl ::flatbuffers::Verifiable for MediaInfo<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<MediaKind>("kind", Self::VT_KIND, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<ImageSet>>("images", Self::VT_IMAGES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("original_title", Self::VT_ORIGINAL_TITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<u32>("score", Self::VT_SCORE, false)?
     .visit_field::<u64>("scored_by", Self::VT_SCORED_BY, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("year", Self::VT_YEAR, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("release_date", Self::VT_RELEASE_DATE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("genres", Self::VT_GENRES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("tags", Self::VT_TAGS, false)?
     .visit_field::<Status>("status", Self::VT_STATUS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("content_rating", Self::VT_CONTENT_RATING, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Season>>>>("seasons", Self::VT_SEASONS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Person>>>>("cast", Self::VT_CAST, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Person>>>>("crew", Self::VT_CREW, false)?
     .visit_field::<u32>("runtime_minutes", Self::VT_RUNTIME_MINUTES, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("trailer_url", Self::VT_TRAILER_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<LinkedId>>>>("ids", Self::VT_IDS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("studio", Self::VT_STUDIO, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("country", Self::VT_COUNTRY, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("language", Self::VT_LANGUAGE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Attr>>>>("extra", Self::VT_EXTRA, false)?
     .finish();
    Ok(())
  }
}
pub struct MediaInfoArgs<'a> {
    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub kind: MediaKind,
    pub images: Option<::flatbuffers::WIPOffset<ImageSet<'a>>>,
    pub original_title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub description: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub score: u32,
    pub scored_by: u64,
    pub year: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub release_date: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub genres: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub tags: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub status: Status,
    pub content_rating: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub seasons: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Season<'a>>>>>,
    pub cast: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Person<'a>>>>>,
    pub crew: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Person<'a>>>>>,
    pub runtime_minutes: u32,
    pub trailer_url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub ids: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LinkedId<'a>>>>>,
    pub studio: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub country: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub language: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub extra: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Attr<'a>>>>>,
}
impl<'a> Default for MediaInfoArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaInfoArgs {
      id: None,
      title: None,
      kind: MediaKind::Movie,
      images: None,
      original_title: None,
      description: None,
      score: 0,
      scored_by: 0,
      year: None,
      release_date: None,
      genres: None,
      tags: None,
      status: Status::Unknown,
      content_rating: None,
      seasons: None,
      cast: None,
      crew: None,
      runtime_minutes: 0,
      trailer_url: None,
      ids: None,
      studio: None,
      country: None,
      language: None,
      url: None,
      extra: None,
    }
  }
}

pub struct MediaInfoBuilder<'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> MediaInfoBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_ID, id);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_TITLE, title);
  }
  #[inline]
  pub fn add_kind(&mut self, kind: MediaKind) {
    self.fbb_.push_slot::<MediaKind>(MediaInfo::VT_KIND, kind, MediaKind::Movie);
  }
  #[inline]
  pub fn add_images(&mut self, images: ::flatbuffers::WIPOffset<ImageSet<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<ImageSet>>(MediaInfo::VT_IMAGES, images);
  }
  #[inline]
  pub fn add_original_title(&mut self, original_title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_ORIGINAL_TITLE, original_title);
  }
  #[inline]
  pub fn add_description(&mut self, description: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_score(&mut self, score: u32) {
    self.fbb_.push_slot::<u32>(MediaInfo::VT_SCORE, score, 0);
  }
  #[inline]
  pub fn add_scored_by(&mut self, scored_by: u64) {
    self.fbb_.push_slot::<u64>(MediaInfo::VT_SCORED_BY, scored_by, 0);
  }
  #[inline]
  pub fn add_year(&mut self, year: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_YEAR, year);
  }
  #[inline]
  pub fn add_release_date(&mut self, release_date: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_RELEASE_DATE, release_date);
  }
  #[inline]
  pub fn add_genres(&mut self, genres: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_GENRES, genres);
  }
  #[inline]
  pub fn add_tags(&mut self, tags: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_TAGS, tags);
  }
  #[inline]
  pub fn add_status(&mut self, status: Status) {
    self.fbb_.push_slot::<Status>(MediaInfo::VT_STATUS, status, Status::Unknown);
  }
  #[inline]
  pub fn add_content_rating(&mut self, content_rating: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_CONTENT_RATING, content_rating);
  }
  #[inline]
  pub fn add_seasons(&mut self, seasons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Season<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_SEASONS, seasons);
  }
  #[inline]
  pub fn add_cast(&mut self, cast: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Person<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_CAST, cast);
  }
  #[inline]
  pub fn add_crew(&mut self, crew: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Person<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_CREW, crew);
  }
  #[inline]
  pub fn add_runtime_minutes(&mut self, runtime_minutes: u32) {
    self.fbb_.push_slot::<u32>(MediaInfo::VT_RUNTIME_MINUTES, runtime_minutes, 0);
  }
  #[inline]
  pub fn add_trailer_url(&mut self, trailer_url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_TRAILER_URL, trailer_url);
  }
  #[inline]
  pub fn add_ids(&mut self, ids: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<LinkedId<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_IDS, ids);
  }
  #[inline]
  pub fn add_studio(&mut self, studio: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_STUDIO, studio);
  }
  #[inline]
  pub fn add_country(&mut self, country: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_COUNTRY, country);
  }
  #[inline]
  pub fn add_language(&mut self, language: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_LANGUAGE, language);
  }
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_URL, url);
  }
  #[inline]
  pub fn add_extra(&mut self, extra: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Attr<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaInfo::VT_EXTRA, extra);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MediaInfoBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaInfoBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MediaInfo<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for MediaInfo<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MediaInfo");
      ds.field("id", &self.id());
      ds.field("title", &self.title());
      ds.field("kind", &self.kind());
      ds.field("images", &self.images());
      ds.field("original_title", &self.original_title());
      ds.field("description", &self.description());
      ds.field("score", &self.score());
      ds.field("scored_by", &self.scored_by());
      ds.field("year", &self.year());
      ds.field("release_date", &self.release_date());
      ds.field("genres", &self.genres());
      ds.field("tags", &self.tags());
      ds.field("status", &self.status());
      ds.field("content_rating", &self.content_rating());
      ds.field("seasons", &self.seasons());
      ds.field("cast", &self.cast());
      ds.field("crew", &self.crew());
      ds.field("runtime_minutes", &self.runtime_minutes());
      ds.field("trailer_url", &self.trailer_url());
      ds.field("ids", &self.ids());
      ds.field("studio", &self.studio());
      ds.field("country", &self.country());
      ds.field("language", &self.language());
      ds.field("url", &self.url());
      ds.field("extra", &self.extra());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `MediaInfo`
/// 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_media_info_unchecked`.
pub fn root_as_media_info(buf: &[u8]) -> Result<MediaInfo<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<MediaInfo>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `MediaInfo` 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_media_info_unchecked`.
pub fn size_prefixed_root_as_media_info(buf: &[u8]) -> Result<MediaInfo<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<MediaInfo>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `MediaInfo` 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_media_info_unchecked`.
pub fn root_as_media_info_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<MediaInfo<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<MediaInfo<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `MediaInfo` 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_media_info_unchecked`.
pub fn size_prefixed_root_as_media_info_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<MediaInfo<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<MediaInfo<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a MediaInfo and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `MediaInfo`.
pub unsafe fn root_as_media_info_unchecked(buf: &[u8]) -> MediaInfo<'_> {
  unsafe { ::flatbuffers::root_unchecked::<MediaInfo>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed MediaInfo and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `MediaInfo`.
pub unsafe fn size_prefixed_root_as_media_info_unchecked(buf: &[u8]) -> MediaInfo<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<MediaInfo>(buf) }
}
#[inline]
pub fn finish_media_info_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<MediaInfo<'a>>) {
  fbb.finish(root, None);
}

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