fcast-protocol 0.1.4

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


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

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


#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MESSAGE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MESSAGE: u8 = 23;
#[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_MESSAGE: [Message; 24] = [
  Message::NONE,
  Message::Load,
  Message::ProgressChanged,
  Message::VolumeChanged,
  Message::PlaybackStateChanged,
  Message::SpeedChanged,
  Message::SenderIntroduction,
  Message::ReceiverIntroduction,
  Message::StopPlayback,
  Message::StartMirroringSession,
  Message::MirroringSessionDescription,
  Message::QueueInsert,
  Message::QueueRemove,
  Message::TracksAvailable,
  Message::ChangeTrack,
  Message::QueueItemSelected,
  Message::AddSubtitleSource,
  Message::SetProgressUpdateInterval,
  Message::CompanionHelloRequest,
  Message::CompanionHelloResponse,
  Message::CompanionResourceInfoRequest,
  Message::CompanionResourceInfoResponse,
  Message::CompanionResourceRequest,
  Message::Error,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Message(pub u8);
#[allow(non_upper_case_globals)]
impl Message {
  pub const NONE: Self = Self(0);
  pub const Load: Self = Self(1);
  pub const ProgressChanged: Self = Self(2);
  pub const VolumeChanged: Self = Self(3);
  pub const PlaybackStateChanged: Self = Self(4);
  pub const SpeedChanged: Self = Self(5);
  pub const SenderIntroduction: Self = Self(6);
  pub const ReceiverIntroduction: Self = Self(7);
  pub const StopPlayback: Self = Self(8);
  pub const StartMirroringSession: Self = Self(9);
  pub const MirroringSessionDescription: Self = Self(10);
  pub const QueueInsert: Self = Self(11);
  pub const QueueRemove: Self = Self(12);
  pub const TracksAvailable: Self = Self(13);
  pub const ChangeTrack: Self = Self(14);
  pub const QueueItemSelected: Self = Self(15);
  pub const AddSubtitleSource: Self = Self(16);
  pub const SetProgressUpdateInterval: Self = Self(17);
  pub const CompanionHelloRequest: Self = Self(18);
  pub const CompanionHelloResponse: Self = Self(19);
  pub const CompanionResourceInfoRequest: Self = Self(20);
  pub const CompanionResourceInfoResponse: Self = Self(21);
  pub const CompanionResourceRequest: Self = Self(22);
  pub const Error: Self = Self(23);

  pub const ENUM_MIN: u8 = 0;
  pub const ENUM_MAX: u8 = 23;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::NONE,
    Self::Load,
    Self::ProgressChanged,
    Self::VolumeChanged,
    Self::PlaybackStateChanged,
    Self::SpeedChanged,
    Self::SenderIntroduction,
    Self::ReceiverIntroduction,
    Self::StopPlayback,
    Self::StartMirroringSession,
    Self::MirroringSessionDescription,
    Self::QueueInsert,
    Self::QueueRemove,
    Self::TracksAvailable,
    Self::ChangeTrack,
    Self::QueueItemSelected,
    Self::AddSubtitleSource,
    Self::SetProgressUpdateInterval,
    Self::CompanionHelloRequest,
    Self::CompanionHelloResponse,
    Self::CompanionResourceInfoRequest,
    Self::CompanionResourceInfoResponse,
    Self::CompanionResourceRequest,
    Self::Error,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::NONE => Some("NONE"),
      Self::Load => Some("Load"),
      Self::ProgressChanged => Some("ProgressChanged"),
      Self::VolumeChanged => Some("VolumeChanged"),
      Self::PlaybackStateChanged => Some("PlaybackStateChanged"),
      Self::SpeedChanged => Some("SpeedChanged"),
      Self::SenderIntroduction => Some("SenderIntroduction"),
      Self::ReceiverIntroduction => Some("ReceiverIntroduction"),
      Self::StopPlayback => Some("StopPlayback"),
      Self::StartMirroringSession => Some("StartMirroringSession"),
      Self::MirroringSessionDescription => Some("MirroringSessionDescription"),
      Self::QueueInsert => Some("QueueInsert"),
      Self::QueueRemove => Some("QueueRemove"),
      Self::TracksAvailable => Some("TracksAvailable"),
      Self::ChangeTrack => Some("ChangeTrack"),
      Self::QueueItemSelected => Some("QueueItemSelected"),
      Self::AddSubtitleSource => Some("AddSubtitleSource"),
      Self::SetProgressUpdateInterval => Some("SetProgressUpdateInterval"),
      Self::CompanionHelloRequest => Some("CompanionHelloRequest"),
      Self::CompanionHelloResponse => Some("CompanionHelloResponse"),
      Self::CompanionResourceInfoRequest => Some("CompanionResourceInfoRequest"),
      Self::CompanionResourceInfoResponse => Some("CompanionResourceInfoResponse"),
      Self::CompanionResourceRequest => Some("CompanionResourceRequest"),
      Self::Error => Some("Error"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for Message {
  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 Message {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
    Self(b)
  }
}

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for Message {}
pub struct MessageUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_PLAYBACK_STATE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_PLAYBACK_STATE: u8 = 4;
#[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_PLAYBACK_STATE: [PlaybackState; 5] = [
  PlaybackState::Idle,
  PlaybackState::Buffering,
  PlaybackState::Playing,
  PlaybackState::Paused,
  PlaybackState::Ended,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct PlaybackState(pub u8);
#[allow(non_upper_case_globals)]
impl PlaybackState {
  pub const Idle: Self = Self(0);
  pub const Buffering: Self = Self(1);
  pub const Playing: Self = Self(2);
  pub const Paused: Self = Self(3);
  pub const Ended: Self = Self(4);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for PlaybackState {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_METADATA: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_METADATA: u8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_METADATA: [Metadata; 3] = [
  Metadata::NONE,
  Metadata::Video,
  Metadata::Audio,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Metadata(pub u8);
#[allow(non_upper_case_globals)]
impl Metadata {
  pub const NONE: Self = Self(0);
  pub const Video: Self = Self(1);
  pub const Audio: Self = Self(2);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for Metadata {}
pub struct MetadataUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_GENERIC_META_VALUE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_GENERIC_META_VALUE: u8 = 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_GENERIC_META_VALUE: [GenericMetaValue; 6] = [
  GenericMetaValue::NONE,
  GenericMetaValue::String,
  GenericMetaValue::Float,
  GenericMetaValue::Int,
  GenericMetaValue::List,
  GenericMetaValue::KVPair,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct GenericMetaValue(pub u8);
#[allow(non_upper_case_globals)]
impl GenericMetaValue {
  pub const NONE: Self = Self(0);
  pub const String: Self = Self(1);
  pub const Float: Self = Self(2);
  pub const Int: Self = Self(3);
  pub const List: Self = Self(4);
  pub const KVPair: Self = Self(5);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for GenericMetaValue {}
pub struct GenericMetaValueUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MEDIA_SOURCE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MEDIA_SOURCE: u8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_MEDIA_SOURCE: [MediaSource; 3] = [
  MediaSource::NONE,
  MediaSource::Single,
  MediaSource::Queue,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct MediaSource(pub u8);
#[allow(non_upper_case_globals)]
impl MediaSource {
  pub const NONE: Self = Self(0);
  pub const Single: Self = Self(1);
  pub const Queue: Self = Self(2);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for MediaSource {}
pub struct MediaSourceUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_QUEUE_POSITION: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_QUEUE_POSITION: u8 = 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_QUEUE_POSITION: [QueuePosition; 4] = [
  QueuePosition::NONE,
  QueuePosition::Index,
  QueuePosition::Front,
  QueuePosition::Back,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct QueuePosition(pub u8);
#[allow(non_upper_case_globals)]
impl QueuePosition {
  pub const NONE: Self = Self(0);
  pub const Index: Self = Self(1);
  pub const Front: Self = Self(2);
  pub const Back: Self = Self(3);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for QueuePosition {}
pub struct QueuePositionUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MEDIA_TRACK_METADATA: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MEDIA_TRACK_METADATA: u8 = 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_MEDIA_TRACK_METADATA: [MediaTrackMetadata; 4] = [
  MediaTrackMetadata::NONE,
  MediaTrackMetadata::Video,
  MediaTrackMetadata::Audio,
  MediaTrackMetadata::Subtitle,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct MediaTrackMetadata(pub u8);
#[allow(non_upper_case_globals)]
impl MediaTrackMetadata {
  pub const NONE: Self = Self(0);
  pub const Video: Self = Self(1);
  pub const Audio: Self = Self(2);
  pub const Subtitle: Self = Self(3);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for MediaTrackMetadata {}
pub struct MediaTrackMetadataUnionTableOffset {}

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MEDIA_TRACK_TYPE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MEDIA_TRACK_TYPE: u8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_MEDIA_TRACK_TYPE: [MediaTrackType; 3] = [
  MediaTrackType::Video,
  MediaTrackType::Audio,
  MediaTrackType::Subtitle,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct MediaTrackType(pub u8);
#[allow(non_upper_case_globals)]
impl MediaTrackType {
  pub const Video: Self = Self(0);
  pub const Audio: Self = Self(1);
  pub const Subtitle: Self = Self(2);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for MediaTrackType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_ERROR_KIND: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ERROR_KIND: u8 = 12;
#[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_ERROR_KIND: [ErrorKind; 13] = [
  ErrorKind::InvalidOpcode,
  ErrorKind::ResourceNotFound,
  ErrorKind::SeekOutOfRange,
  ErrorKind::VolumeOutOfRange,
  ErrorKind::RateOutOfRange,
  ErrorKind::UnsupportedFormat,
  ErrorKind::MalformedBody,
  ErrorKind::InvalidState,
  ErrorKind::QueuePositionOutOfRange,
  ErrorKind::QueueRemovePlayingItem,
  ErrorKind::QueueFull,
  ErrorKind::InvalidPayloadType,
  ErrorKind::Internal,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ErrorKind(pub u8);
#[allow(non_upper_case_globals)]
impl ErrorKind {
  pub const InvalidOpcode: Self = Self(0);
  pub const ResourceNotFound: Self = Self(1);
  pub const SeekOutOfRange: Self = Self(2);
  pub const VolumeOutOfRange: Self = Self(3);
  pub const RateOutOfRange: Self = Self(4);
  pub const UnsupportedFormat: Self = Self(5);
  pub const MalformedBody: Self = Self(6);
  pub const InvalidState: Self = Self(7);
  pub const QueuePositionOutOfRange: Self = Self(8);
  pub const QueueRemovePlayingItem: Self = Self(9);
  pub const QueueFull: Self = Self(10);
  pub const InvalidPayloadType: Self = Self(11);
  pub const Internal: Self = Self(12);

  pub const ENUM_MIN: u8 = 0;
  pub const ENUM_MAX: u8 = 12;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::InvalidOpcode,
    Self::ResourceNotFound,
    Self::SeekOutOfRange,
    Self::VolumeOutOfRange,
    Self::RateOutOfRange,
    Self::UnsupportedFormat,
    Self::MalformedBody,
    Self::InvalidState,
    Self::QueuePositionOutOfRange,
    Self::QueueRemovePlayingItem,
    Self::QueueFull,
    Self::InvalidPayloadType,
    Self::Internal,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::InvalidOpcode => Some("InvalidOpcode"),
      Self::ResourceNotFound => Some("ResourceNotFound"),
      Self::SeekOutOfRange => Some("SeekOutOfRange"),
      Self::VolumeOutOfRange => Some("VolumeOutOfRange"),
      Self::RateOutOfRange => Some("RateOutOfRange"),
      Self::UnsupportedFormat => Some("UnsupportedFormat"),
      Self::MalformedBody => Some("MalformedBody"),
      Self::InvalidState => Some("InvalidState"),
      Self::QueuePositionOutOfRange => Some("QueuePositionOutOfRange"),
      Self::QueueRemovePlayingItem => Some("QueueRemovePlayingItem"),
      Self::QueueFull => Some("QueueFull"),
      Self::InvalidPayloadType => Some("InvalidPayloadType"),
      Self::Internal => Some("Internal"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for ErrorKind {
  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 ErrorKind {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
    Self(b)
  }
}

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for ErrorKind {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_COMPANION_RESOURCE_SIZE: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_COMPANION_RESOURCE_SIZE: u8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_COMPANION_RESOURCE_SIZE: [CompanionResourceSize; 3] = [
  CompanionResourceSize::NONE,
  CompanionResourceSize::Unknown,
  CompanionResourceSize::Known,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct CompanionResourceSize(pub u8);
#[allow(non_upper_case_globals)]
impl CompanionResourceSize {
  pub const NONE: Self = Self(0);
  pub const Unknown: Self = Self(1);
  pub const Known: Self = Self(2);

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

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

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

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

impl ::flatbuffers::SimpleToVerifyInSlice for CompanionResourceSize {}
pub struct CompanionResourceSizeUnionTableOffset {}

// struct Time, aligned to 8
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Time(pub [u8; 8]);
impl Default for Time { 
  fn default() -> Self { 
    Self([0; 8])
  }
}
impl ::core::fmt::Debug for Time {
  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
    f.debug_struct("Time")
      .field("micros", &self.micros())
      .finish()
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for Time {}
impl<'a> ::flatbuffers::Follow<'a> for Time {
  type Inner = &'a Time;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { <&'a Time>::follow(buf, loc) }
  }
}
impl<'a> ::flatbuffers::Follow<'a> for &'a Time {
  type Inner = &'a Time;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { ::flatbuffers::follow_cast_ref::<Time>(buf, loc) }
  }
}
impl<'b> ::flatbuffers::Push for Time {
    type Output = Time;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const Time as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(8)
    }
}

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

impl<'a> Time {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    micros: u64,
  ) -> Self {
    let mut s = Self([0; 8]);
    s.set_micros(micros);
    s
  }

  pub fn micros(&self) -> u64 {
    let mut mem = ::core::mem::MaybeUninit::<<u64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[0..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_micros(&mut self, x: u64) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[0..].as_mut_ptr(),
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

}

// struct VideoResolution, aligned to 4
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct VideoResolution(pub [u8; 8]);
impl Default for VideoResolution { 
  fn default() -> Self { 
    Self([0; 8])
  }
}
impl ::core::fmt::Debug for VideoResolution {
  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
    f.debug_struct("VideoResolution")
      .field("width", &self.width())
      .field("height", &self.height())
      .finish()
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for VideoResolution {}
impl<'a> ::flatbuffers::Follow<'a> for VideoResolution {
  type Inner = &'a VideoResolution;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { <&'a VideoResolution>::follow(buf, loc) }
  }
}
impl<'a> ::flatbuffers::Follow<'a> for &'a VideoResolution {
  type Inner = &'a VideoResolution;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { ::flatbuffers::follow_cast_ref::<VideoResolution>(buf, loc) }
  }
}
impl<'b> ::flatbuffers::Push for VideoResolution {
    type Output = VideoResolution;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const VideoResolution as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(4)
    }
}

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

impl<'a> VideoResolution {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    width: u32,
    height: u32,
  ) -> Self {
    let mut s = Self([0; 8]);
    s.set_width(width);
    s.set_height(height);
    s
  }

  pub fn width(&self) -> u32 {
    let mut mem = ::core::mem::MaybeUninit::<<u32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[0..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_width(&mut self, x: u32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[0..].as_mut_ptr(),
        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn height(&self) -> u32 {
    let mut mem = ::core::mem::MaybeUninit::<<u32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[4..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_height(&mut self, x: u32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[4..].as_mut_ptr(),
        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

}

// struct ResourceReadHead, aligned to 8
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct ResourceReadHead(pub [u8; 16]);
impl Default for ResourceReadHead { 
  fn default() -> Self { 
    Self([0; 16])
  }
}
impl ::core::fmt::Debug for ResourceReadHead {
  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
    f.debug_struct("ResourceReadHead")
      .field("start", &self.start())
      .field("stop_inclusive", &self.stop_inclusive())
      .finish()
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for ResourceReadHead {}
impl<'a> ::flatbuffers::Follow<'a> for ResourceReadHead {
  type Inner = &'a ResourceReadHead;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { <&'a ResourceReadHead>::follow(buf, loc) }
  }
}
impl<'a> ::flatbuffers::Follow<'a> for &'a ResourceReadHead {
  type Inner = &'a ResourceReadHead;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { ::flatbuffers::follow_cast_ref::<ResourceReadHead>(buf, loc) }
  }
}
impl<'b> ::flatbuffers::Push for ResourceReadHead {
    type Output = ResourceReadHead;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const ResourceReadHead as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(8)
    }
}

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

impl<'a> ResourceReadHead {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    start: u64,
    stop_inclusive: u64,
  ) -> Self {
    let mut s = Self([0; 16]);
    s.set_start(start);
    s.set_stop_inclusive(stop_inclusive);
    s
  }

  pub fn start(&self) -> u64 {
    let mut mem = ::core::mem::MaybeUninit::<<u64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[0..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_start(&mut self, x: u64) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[0..].as_mut_ptr(),
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn stop_inclusive(&self) -> u64 {
    let mut mem = ::core::mem::MaybeUninit::<<u64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[8..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_stop_inclusive(&mut self, x: u64) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[8..].as_mut_ptr(),
        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> Packet<'a> {
  pub const VT_PAYLOAD_TYPE: ::flatbuffers::VOffsetT = 4;
  pub const VT_PAYLOAD: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Packet { _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 PacketArgs
  ) -> ::flatbuffers::WIPOffset<Packet<'bldr>> {
    let mut builder = PacketBuilder::new(_fbb);
    if let Some(x) = args.payload { builder.add_payload(x); }
    builder.add_payload_type(args.payload_type);
    builder.finish()
  }


  #[inline]
  pub fn payload_type(&self) -> Message {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Message>(Packet::VT_PAYLOAD_TYPE, Some(Message::NONE)).unwrap()}
  }
  #[inline]
  pub fn payload(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Packet::VT_PAYLOAD, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_load(&self) -> Option<Load<'a>> {
    if self.payload_type() == Message::Load {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { Load::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_progress_changed(&self) -> Option<ProgressChanged<'a>> {
    if self.payload_type() == Message::ProgressChanged {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { ProgressChanged::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_volume_changed(&self) -> Option<VolumeChanged<'a>> {
    if self.payload_type() == Message::VolumeChanged {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { VolumeChanged::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_playback_state_changed(&self) -> Option<PlaybackStateChanged<'a>> {
    if self.payload_type() == Message::PlaybackStateChanged {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { PlaybackStateChanged::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_speed_changed(&self) -> Option<SpeedChanged<'a>> {
    if self.payload_type() == Message::SpeedChanged {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { SpeedChanged::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_sender_introduction(&self) -> Option<SenderIntroduction<'a>> {
    if self.payload_type() == Message::SenderIntroduction {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { SenderIntroduction::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_receiver_introduction(&self) -> Option<ReceiverIntroduction<'a>> {
    if self.payload_type() == Message::ReceiverIntroduction {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { ReceiverIntroduction::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_stop_playback(&self) -> Option<StopPlayback<'a>> {
    if self.payload_type() == Message::StopPlayback {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { StopPlayback::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_start_mirroring_session(&self) -> Option<StartMirroringSession<'a>> {
    if self.payload_type() == Message::StartMirroringSession {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { StartMirroringSession::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_mirroring_session_description(&self) -> Option<MirroringSessionDescription<'a>> {
    if self.payload_type() == Message::MirroringSessionDescription {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { MirroringSessionDescription::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_queue_insert(&self) -> Option<QueueInsert<'a>> {
    if self.payload_type() == Message::QueueInsert {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { QueueInsert::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_queue_remove(&self) -> Option<QueueRemove<'a>> {
    if self.payload_type() == Message::QueueRemove {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { QueueRemove::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_tracks_available(&self) -> Option<TracksAvailable<'a>> {
    if self.payload_type() == Message::TracksAvailable {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { TracksAvailable::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_change_track(&self) -> Option<ChangeTrack<'a>> {
    if self.payload_type() == Message::ChangeTrack {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { ChangeTrack::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_queue_item_selected(&self) -> Option<QueueItemSelected<'a>> {
    if self.payload_type() == Message::QueueItemSelected {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { QueueItemSelected::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_add_subtitle_source(&self) -> Option<AddSubtitleSource<'a>> {
    if self.payload_type() == Message::AddSubtitleSource {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { AddSubtitleSource::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_set_progress_update_interval(&self) -> Option<SetProgressUpdateInterval<'a>> {
    if self.payload_type() == Message::SetProgressUpdateInterval {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { SetProgressUpdateInterval::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_companion_hello_request(&self) -> Option<CompanionHelloRequest<'a>> {
    if self.payload_type() == Message::CompanionHelloRequest {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { CompanionHelloRequest::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_companion_hello_response(&self) -> Option<CompanionHelloResponse<'a>> {
    if self.payload_type() == Message::CompanionHelloResponse {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { CompanionHelloResponse::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_companion_resource_info_request(&self) -> Option<CompanionResourceInfoRequest<'a>> {
    if self.payload_type() == Message::CompanionResourceInfoRequest {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { CompanionResourceInfoRequest::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_companion_resource_info_response(&self) -> Option<CompanionResourceInfoResponse<'a>> {
    if self.payload_type() == Message::CompanionResourceInfoResponse {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { CompanionResourceInfoResponse::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_companion_resource_request(&self) -> Option<CompanionResourceRequest<'a>> {
    if self.payload_type() == Message::CompanionResourceRequest {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { CompanionResourceRequest::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn payload_as_error(&self) -> Option<Error<'a>> {
    if self.payload_type() == Message::Error {
      self.payload().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { Error::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for Packet<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<Message, _>("payload_type", Self::VT_PAYLOAD_TYPE, "payload", Self::VT_PAYLOAD, false, |key, v, pos| {
        match key {
          Message::Load => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Load>>("Message::Load", pos),
          Message::ProgressChanged => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ProgressChanged>>("Message::ProgressChanged", pos),
          Message::VolumeChanged => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<VolumeChanged>>("Message::VolumeChanged", pos),
          Message::PlaybackStateChanged => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<PlaybackStateChanged>>("Message::PlaybackStateChanged", pos),
          Message::SpeedChanged => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SpeedChanged>>("Message::SpeedChanged", pos),
          Message::SenderIntroduction => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SenderIntroduction>>("Message::SenderIntroduction", pos),
          Message::ReceiverIntroduction => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ReceiverIntroduction>>("Message::ReceiverIntroduction", pos),
          Message::StopPlayback => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StopPlayback>>("Message::StopPlayback", pos),
          Message::StartMirroringSession => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<StartMirroringSession>>("Message::StartMirroringSession", pos),
          Message::MirroringSessionDescription => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MirroringSessionDescription>>("Message::MirroringSessionDescription", pos),
          Message::QueueInsert => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueInsert>>("Message::QueueInsert", pos),
          Message::QueueRemove => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueRemove>>("Message::QueueRemove", pos),
          Message::TracksAvailable => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<TracksAvailable>>("Message::TracksAvailable", pos),
          Message::ChangeTrack => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ChangeTrack>>("Message::ChangeTrack", pos),
          Message::QueueItemSelected => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueItemSelected>>("Message::QueueItemSelected", pos),
          Message::AddSubtitleSource => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AddSubtitleSource>>("Message::AddSubtitleSource", pos),
          Message::SetProgressUpdateInterval => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SetProgressUpdateInterval>>("Message::SetProgressUpdateInterval", pos),
          Message::CompanionHelloRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CompanionHelloRequest>>("Message::CompanionHelloRequest", pos),
          Message::CompanionHelloResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CompanionHelloResponse>>("Message::CompanionHelloResponse", pos),
          Message::CompanionResourceInfoRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CompanionResourceInfoRequest>>("Message::CompanionResourceInfoRequest", pos),
          Message::CompanionResourceInfoResponse => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CompanionResourceInfoResponse>>("Message::CompanionResourceInfoResponse", pos),
          Message::CompanionResourceRequest => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<CompanionResourceRequest>>("Message::CompanionResourceRequest", pos),
          Message::Error => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Error>>("Message::Error", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct PacketArgs {
    pub payload_type: Message,
    pub payload: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for PacketArgs {
  #[inline]
  fn default() -> Self {
    PacketArgs {
      payload_type: Message::NONE,
      payload: None,
    }
  }
}

pub struct PacketBuilder<'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> PacketBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_payload_type(&mut self, payload_type: Message) {
    self.fbb_.push_slot::<Message>(Packet::VT_PAYLOAD_TYPE, payload_type, Message::NONE);
  }
  #[inline]
  pub fn add_payload(&mut self, payload: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Packet::VT_PAYLOAD, payload);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PacketBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PacketBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Packet<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Packet<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Packet");
      ds.field("payload_type", &self.payload_type());
      match self.payload_type() {
        Message::Load => {
          if let Some(x) = self.payload_as_load() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::ProgressChanged => {
          if let Some(x) = self.payload_as_progress_changed() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::VolumeChanged => {
          if let Some(x) = self.payload_as_volume_changed() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::PlaybackStateChanged => {
          if let Some(x) = self.payload_as_playback_state_changed() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::SpeedChanged => {
          if let Some(x) = self.payload_as_speed_changed() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::SenderIntroduction => {
          if let Some(x) = self.payload_as_sender_introduction() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::ReceiverIntroduction => {
          if let Some(x) = self.payload_as_receiver_introduction() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::StopPlayback => {
          if let Some(x) = self.payload_as_stop_playback() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::StartMirroringSession => {
          if let Some(x) = self.payload_as_start_mirroring_session() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::MirroringSessionDescription => {
          if let Some(x) = self.payload_as_mirroring_session_description() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::QueueInsert => {
          if let Some(x) = self.payload_as_queue_insert() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::QueueRemove => {
          if let Some(x) = self.payload_as_queue_remove() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::TracksAvailable => {
          if let Some(x) = self.payload_as_tracks_available() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::ChangeTrack => {
          if let Some(x) = self.payload_as_change_track() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::QueueItemSelected => {
          if let Some(x) = self.payload_as_queue_item_selected() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::AddSubtitleSource => {
          if let Some(x) = self.payload_as_add_subtitle_source() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::SetProgressUpdateInterval => {
          if let Some(x) = self.payload_as_set_progress_update_interval() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::CompanionHelloRequest => {
          if let Some(x) = self.payload_as_companion_hello_request() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::CompanionHelloResponse => {
          if let Some(x) = self.payload_as_companion_hello_response() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::CompanionResourceInfoRequest => {
          if let Some(x) = self.payload_as_companion_resource_info_request() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::CompanionResourceInfoResponse => {
          if let Some(x) = self.payload_as_companion_resource_info_response() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::CompanionResourceRequest => {
          if let Some(x) = self.payload_as_companion_resource_request() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Message::Error => {
          if let Some(x) = self.payload_as_error() {
            ds.field("payload", &x)
          } else {
            ds.field("payload", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("payload", &x)
        },
      };
      ds.finish()
  }
}
pub enum ChapterOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> Chapter<'a> {
  pub const VT_START: ::flatbuffers::VOffsetT = 4;
  pub const VT_LENGTH: ::flatbuffers::VOffsetT = 6;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 8;
  pub const VT_SKIP_LABEL: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Chapter { _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 ChapterArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Chapter<'bldr>> {
    let mut builder = ChapterBuilder::new(_fbb);
    if let Some(x) = args.skip_label { builder.add_skip_label(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.length { builder.add_length(x); }
    if let Some(x) = args.start { builder.add_start(x); }
    builder.finish()
  }


  #[inline]
  pub fn start(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(Chapter::VT_START, None)}
  }
  #[inline]
  pub fn length(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(Chapter::VT_LENGTH, None)}
  }
  #[inline]
  pub fn title(&self) -> &'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>>(Chapter::VT_TITLE, None).unwrap()}
  }
  #[inline]
  pub fn skip_label(&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>>(Chapter::VT_SKIP_LABEL, None)}
  }
}

impl ::flatbuffers::Verifiable for Chapter<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Time>("start", Self::VT_START, false)?
     .visit_field::<Time>("length", Self::VT_LENGTH, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("skip_label", Self::VT_SKIP_LABEL, false)?
     .finish();
    Ok(())
  }
}
pub struct ChapterArgs<'a> {
    pub start: Option<&'a Time>,
    pub length: Option<&'a Time>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub skip_label: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ChapterArgs<'a> {
  #[inline]
  fn default() -> Self {
    ChapterArgs {
      start: None,
      length: None,
      title: None, // required field
      skip_label: None,
    }
  }
}

pub struct ChapterBuilder<'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> ChapterBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_start(&mut self, start: &Time) {
    self.fbb_.push_slot_always::<&Time>(Chapter::VT_START, start);
  }
  #[inline]
  pub fn add_length(&mut self, length: &Time) {
    self.fbb_.push_slot_always::<&Time>(Chapter::VT_LENGTH, length);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Chapter::VT_TITLE, title);
  }
  #[inline]
  pub fn add_skip_label(&mut self, skip_label: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Chapter::VT_SKIP_LABEL, skip_label);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ChapterBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ChapterBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Chapter<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Chapter::VT_TITLE,"title");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> VideoMetadata<'a> {
  pub const VT_CHAPTERS: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn chapters(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Chapter<'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<Chapter>>>>(VideoMetadata::VT_CHAPTERS, None)}
  }
}

impl ::flatbuffers::Verifiable for VideoMetadata<'_> {
  #[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<Chapter>>>>("chapters", Self::VT_CHAPTERS, false)?
     .finish();
    Ok(())
  }
}
pub struct VideoMetadataArgs<'a> {
    pub chapters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Chapter<'a>>>>>,
}
impl<'a> Default for VideoMetadataArgs<'a> {
  #[inline]
  fn default() -> Self {
    VideoMetadataArgs {
      chapters: None,
    }
  }
}

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

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

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

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

impl<'a> AudioMetadata<'a> {
  pub const VT_ARTIST: ::flatbuffers::VOffsetT = 4;
  pub const VT_ALBUM: ::flatbuffers::VOffsetT = 6;
  pub const VT_CHAPTERS: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AudioMetadata { _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 AudioMetadataArgs<'args>
  ) -> ::flatbuffers::WIPOffset<AudioMetadata<'bldr>> {
    let mut builder = AudioMetadataBuilder::new(_fbb);
    if let Some(x) = args.chapters { builder.add_chapters(x); }
    if let Some(x) = args.album { builder.add_album(x); }
    if let Some(x) = args.artist { builder.add_artist(x); }
    builder.finish()
  }


  #[inline]
  pub fn artist(&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>>(AudioMetadata::VT_ARTIST, None)}
  }
  #[inline]
  pub fn album(&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>>(AudioMetadata::VT_ALBUM, None)}
  }
  #[inline]
  pub fn chapters(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Chapter<'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<Chapter>>>>(AudioMetadata::VT_CHAPTERS, None)}
  }
}

impl ::flatbuffers::Verifiable for AudioMetadata<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("artist", Self::VT_ARTIST, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("album", Self::VT_ALBUM, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Chapter>>>>("chapters", Self::VT_CHAPTERS, false)?
     .finish();
    Ok(())
  }
}
pub struct AudioMetadataArgs<'a> {
    pub artist: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub album: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub chapters: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Chapter<'a>>>>>,
}
impl<'a> Default for AudioMetadataArgs<'a> {
  #[inline]
  fn default() -> Self {
    AudioMetadataArgs {
      artist: None,
      album: None,
      chapters: None,
    }
  }
}

pub struct AudioMetadataBuilder<'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> AudioMetadataBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_artist(&mut self, artist: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AudioMetadata::VT_ARTIST, artist);
  }
  #[inline]
  pub fn add_album(&mut self, album: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AudioMetadata::VT_ALBUM, album);
  }
  #[inline]
  pub fn add_chapters(&mut self, chapters: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Chapter<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AudioMetadata::VT_CHAPTERS, chapters);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AudioMetadataBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AudioMetadataBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AudioMetadata<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RequestHeader<'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 {
    RequestHeader { _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 RequestHeaderArgs<'args>
  ) -> ::flatbuffers::WIPOffset<RequestHeader<'bldr>> {
    let mut builder = RequestHeaderBuilder::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) -> &'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>>(RequestHeader::VT_KEY, None).unwrap()}
  }
  #[inline]
  pub fn value(&self) -> &'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>>(RequestHeader::VT_VALUE, None).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for RequestHeader<'_> {
  #[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, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, true)?
     .finish();
    Ok(())
  }
}
pub struct RequestHeaderArgs<'a> {
    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub value: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for RequestHeaderArgs<'a> {
  #[inline]
  fn default() -> Self {
    RequestHeaderArgs {
      key: None, // required field
      value: None, // required field
    }
  }
}

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

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

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

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

impl<'a> GenericMetaString<'a> {
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

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


  #[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>>(GenericMetaString::VT_VALUE, None)}
  }
}

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

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

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

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

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

impl<'a> GenericMetaFloat<'a> {
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    GenericMetaFloat { _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 GenericMetaFloatArgs
  ) -> ::flatbuffers::WIPOffset<GenericMetaFloat<'bldr>> {
    let mut builder = GenericMetaFloatBuilder::new(_fbb);
    builder.add_value(args.value);
    builder.finish()
  }


  #[inline]
  pub fn value(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(GenericMetaFloat::VT_VALUE, Some(0.0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for GenericMetaFloat<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<f64>("value", Self::VT_VALUE, false)?
     .finish();
    Ok(())
  }
}
pub struct GenericMetaFloatArgs {
    pub value: f64,
}
impl<'a> Default for GenericMetaFloatArgs {
  #[inline]
  fn default() -> Self {
    GenericMetaFloatArgs {
      value: 0.0,
    }
  }
}

pub struct GenericMetaFloatBuilder<'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> GenericMetaFloatBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_value(&mut self, value: f64) {
    self.fbb_.push_slot::<f64>(GenericMetaFloat::VT_VALUE, value, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GenericMetaFloatBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    GenericMetaFloatBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<GenericMetaFloat<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> GenericMetaInt<'a> {
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    GenericMetaInt { _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 GenericMetaIntArgs
  ) -> ::flatbuffers::WIPOffset<GenericMetaInt<'bldr>> {
    let mut builder = GenericMetaIntBuilder::new(_fbb);
    builder.add_value(args.value);
    builder.finish()
  }


  #[inline]
  pub fn value(&self) -> i64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i64>(GenericMetaInt::VT_VALUE, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for GenericMetaInt<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<i64>("value", Self::VT_VALUE, false)?
     .finish();
    Ok(())
  }
}
pub struct GenericMetaIntArgs {
    pub value: i64,
}
impl<'a> Default for GenericMetaIntArgs {
  #[inline]
  fn default() -> Self {
    GenericMetaIntArgs {
      value: 0,
    }
  }
}

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

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

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

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

impl<'a> GenericMetaList<'a> {
  pub const VT_VALUE: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn value(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<WrappedGenericMetaValue<'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<WrappedGenericMetaValue>>>>(GenericMetaList::VT_VALUE, None)}
  }
}

impl ::flatbuffers::Verifiable for GenericMetaList<'_> {
  #[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<WrappedGenericMetaValue>>>>("value", Self::VT_VALUE, false)?
     .finish();
    Ok(())
  }
}
pub struct GenericMetaListArgs<'a> {
    pub value: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<WrappedGenericMetaValue<'a>>>>>,
}
impl<'a> Default for GenericMetaListArgs<'a> {
  #[inline]
  fn default() -> Self {
    GenericMetaListArgs {
      value: None,
    }
  }
}

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

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

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

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

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

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


  #[inline]
  pub fn value_type(&self) -> GenericMetaValue {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<GenericMetaValue>(WrappedGenericMetaValue::VT_VALUE_TYPE, Some(GenericMetaValue::NONE)).unwrap()}
  }
  #[inline]
  pub fn value(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(WrappedGenericMetaValue::VT_VALUE, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_string(&self) -> Option<GenericMetaString<'a>> {
    if self.value_type() == GenericMetaValue::String {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaString::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_float(&self) -> Option<GenericMetaFloat<'a>> {
    if self.value_type() == GenericMetaValue::Float {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaFloat::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_int(&self) -> Option<GenericMetaInt<'a>> {
    if self.value_type() == GenericMetaValue::Int {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaInt::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_list(&self) -> Option<GenericMetaList<'a>> {
    if self.value_type() == GenericMetaValue::List {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaList::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_kvpair(&self) -> Option<MetadataKV<'a>> {
    if self.value_type() == GenericMetaValue::KVPair {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { MetadataKV::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for WrappedGenericMetaValue<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<GenericMetaValue, _>("value_type", Self::VT_VALUE_TYPE, "value", Self::VT_VALUE, false, |key, v, pos| {
        match key {
          GenericMetaValue::String => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaString>>("GenericMetaValue::String", pos),
          GenericMetaValue::Float => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaFloat>>("GenericMetaValue::Float", pos),
          GenericMetaValue::Int => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaInt>>("GenericMetaValue::Int", pos),
          GenericMetaValue::List => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaList>>("GenericMetaValue::List", pos),
          GenericMetaValue::KVPair => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MetadataKV>>("GenericMetaValue::KVPair", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct WrappedGenericMetaValueArgs {
    pub value_type: GenericMetaValue,
    pub value: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for WrappedGenericMetaValueArgs {
  #[inline]
  fn default() -> Self {
    WrappedGenericMetaValueArgs {
      value_type: GenericMetaValue::NONE,
      value: None,
    }
  }
}

pub struct WrappedGenericMetaValueBuilder<'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> WrappedGenericMetaValueBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_value_type(&mut self, value_type: GenericMetaValue) {
    self.fbb_.push_slot::<GenericMetaValue>(WrappedGenericMetaValue::VT_VALUE_TYPE, value_type, GenericMetaValue::NONE);
  }
  #[inline]
  pub fn add_value(&mut self, value: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(WrappedGenericMetaValue::VT_VALUE, value);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WrappedGenericMetaValueBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    WrappedGenericMetaValueBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<WrappedGenericMetaValue<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for WrappedGenericMetaValue<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("WrappedGenericMetaValue");
      ds.field("value_type", &self.value_type());
      match self.value_type() {
        GenericMetaValue::String => {
          if let Some(x) = self.value_as_string() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::Float => {
          if let Some(x) = self.value_as_float() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::Int => {
          if let Some(x) = self.value_as_int() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::List => {
          if let Some(x) = self.value_as_list() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::KVPair => {
          if let Some(x) = self.value_as_kvpair() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("value", &x)
        },
      };
      ds.finish()
  }
}
pub enum MetadataKVOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

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

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


  #[inline]
  pub fn key(&self) -> &'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>>(MetadataKV::VT_KEY, None).unwrap()}
  }
  #[inline]
  pub fn value_type(&self) -> GenericMetaValue {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<GenericMetaValue>(MetadataKV::VT_VALUE_TYPE, Some(GenericMetaValue::NONE)).unwrap()}
  }
  #[inline]
  pub fn value(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(MetadataKV::VT_VALUE, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_string(&self) -> Option<GenericMetaString<'a>> {
    if self.value_type() == GenericMetaValue::String {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaString::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_float(&self) -> Option<GenericMetaFloat<'a>> {
    if self.value_type() == GenericMetaValue::Float {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaFloat::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_int(&self) -> Option<GenericMetaInt<'a>> {
    if self.value_type() == GenericMetaValue::Int {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaInt::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_list(&self) -> Option<GenericMetaList<'a>> {
    if self.value_type() == GenericMetaValue::List {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { GenericMetaList::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_kvpair(&self) -> Option<MetadataKV<'a>> {
    if self.value_type() == GenericMetaValue::KVPair {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { MetadataKV::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for MetadataKV<'_> {
  #[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, true)?
     .visit_union::<GenericMetaValue, _>("value_type", Self::VT_VALUE_TYPE, "value", Self::VT_VALUE, false, |key, v, pos| {
        match key {
          GenericMetaValue::String => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaString>>("GenericMetaValue::String", pos),
          GenericMetaValue::Float => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaFloat>>("GenericMetaValue::Float", pos),
          GenericMetaValue::Int => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaInt>>("GenericMetaValue::Int", pos),
          GenericMetaValue::List => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<GenericMetaList>>("GenericMetaValue::List", pos),
          GenericMetaValue::KVPair => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MetadataKV>>("GenericMetaValue::KVPair", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct MetadataKVArgs<'a> {
    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub value_type: GenericMetaValue,
    pub value: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for MetadataKVArgs<'a> {
  #[inline]
  fn default() -> Self {
    MetadataKVArgs {
      key: None, // required field
      value_type: GenericMetaValue::NONE,
      value: None,
    }
  }
}

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

impl ::core::fmt::Debug for MetadataKV<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MetadataKV");
      ds.field("key", &self.key());
      ds.field("value_type", &self.value_type());
      match self.value_type() {
        GenericMetaValue::String => {
          if let Some(x) = self.value_as_string() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::Float => {
          if let Some(x) = self.value_as_float() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::Int => {
          if let Some(x) = self.value_as_int() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::List => {
          if let Some(x) = self.value_as_list() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        GenericMetaValue::KVPair => {
          if let Some(x) = self.value_as_kvpair() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("value", &x)
        },
      };
      ds.finish()
  }
}
pub enum MediaItemOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> MediaItem<'a> {
  pub const VT_CONTAINER: ::flatbuffers::VOffsetT = 4;
  pub const VT_SOURCE_URL: ::flatbuffers::VOffsetT = 6;
  pub const VT_START_TIME: ::flatbuffers::VOffsetT = 8;
  pub const VT_VOLUME: ::flatbuffers::VOffsetT = 10;
  pub const VT_SPEED: ::flatbuffers::VOffsetT = 12;
  pub const VT_HEADERS: ::flatbuffers::VOffsetT = 14;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 16;
  pub const VT_THUMBNAIL_URL: ::flatbuffers::VOffsetT = 18;
  pub const VT_METADATA_TYPE: ::flatbuffers::VOffsetT = 20;
  pub const VT_METADATA: ::flatbuffers::VOffsetT = 22;
  pub const VT_EXTRA_METADATA: ::flatbuffers::VOffsetT = 24;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MediaItem { _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 MediaItemArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MediaItem<'bldr>> {
    let mut builder = MediaItemBuilder::new(_fbb);
    if let Some(x) = args.extra_metadata { builder.add_extra_metadata(x); }
    if let Some(x) = args.metadata { builder.add_metadata(x); }
    if let Some(x) = args.thumbnail_url { builder.add_thumbnail_url(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.headers { builder.add_headers(x); }
    if let Some(x) = args.speed { builder.add_speed(x); }
    if let Some(x) = args.volume { builder.add_volume(x); }
    if let Some(x) = args.start_time { builder.add_start_time(x); }
    if let Some(x) = args.source_url { builder.add_source_url(x); }
    if let Some(x) = args.container { builder.add_container(x); }
    builder.add_metadata_type(args.metadata_type);
    builder.finish()
  }


  #[inline]
  pub fn container(&self) -> &'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>>(MediaItem::VT_CONTAINER, None).unwrap()}
  }
  #[inline]
  pub fn source_url(&self) -> &'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>>(MediaItem::VT_SOURCE_URL, None).unwrap()}
  }
  #[inline]
  pub fn start_time(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(MediaItem::VT_START_TIME, None)}
  }
  #[inline]
  pub fn volume(&self) -> Option<f32> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(MediaItem::VT_VOLUME, None)}
  }
  #[inline]
  pub fn speed(&self) -> Option<f32> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(MediaItem::VT_SPEED, None)}
  }
  #[inline]
  pub fn headers(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RequestHeader<'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<RequestHeader>>>>(MediaItem::VT_HEADERS, 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>>(MediaItem::VT_TITLE, None)}
  }
  #[inline]
  pub fn thumbnail_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>>(MediaItem::VT_THUMBNAIL_URL, None)}
  }
  #[inline]
  pub fn metadata_type(&self) -> Metadata {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Metadata>(MediaItem::VT_METADATA_TYPE, Some(Metadata::NONE)).unwrap()}
  }
  #[inline]
  pub fn metadata(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(MediaItem::VT_METADATA, None)}
  }
  #[inline]
  pub fn extra_metadata(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataKV<'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<MetadataKV>>>>(MediaItem::VT_EXTRA_METADATA, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn metadata_as_video(&self) -> Option<VideoMetadata<'a>> {
    if self.metadata_type() == Metadata::Video {
      self.metadata().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { VideoMetadata::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn metadata_as_audio(&self) -> Option<AudioMetadata<'a>> {
    if self.metadata_type() == Metadata::Audio {
      self.metadata().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { AudioMetadata::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for MediaItem<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("container", Self::VT_CONTAINER, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("source_url", Self::VT_SOURCE_URL, true)?
     .visit_field::<Time>("start_time", Self::VT_START_TIME, false)?
     .visit_field::<f32>("volume", Self::VT_VOLUME, false)?
     .visit_field::<f32>("speed", Self::VT_SPEED, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<RequestHeader>>>>("headers", Self::VT_HEADERS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("thumbnail_url", Self::VT_THUMBNAIL_URL, false)?
     .visit_union::<Metadata, _>("metadata_type", Self::VT_METADATA_TYPE, "metadata", Self::VT_METADATA, false, |key, v, pos| {
        match key {
          Metadata::Video => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<VideoMetadata>>("Metadata::Video", pos),
          Metadata::Audio => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AudioMetadata>>("Metadata::Audio", pos),
          _ => Ok(()),
        }
     })?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<MetadataKV>>>>("extra_metadata", Self::VT_EXTRA_METADATA, false)?
     .finish();
    Ok(())
  }
}
pub struct MediaItemArgs<'a> {
    pub container: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub source_url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub start_time: Option<&'a Time>,
    pub volume: Option<f32>,
    pub speed: Option<f32>,
    pub headers: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RequestHeader<'a>>>>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub thumbnail_url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub metadata_type: Metadata,
    pub metadata: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
    pub extra_metadata: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MetadataKV<'a>>>>>,
}
impl<'a> Default for MediaItemArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaItemArgs {
      container: None, // required field
      source_url: None, // required field
      start_time: None,
      volume: None,
      speed: None,
      headers: None,
      title: None,
      thumbnail_url: None,
      metadata_type: Metadata::NONE,
      metadata: None,
      extra_metadata: None,
    }
  }
}

pub struct MediaItemBuilder<'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> MediaItemBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_container(&mut self, container: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_CONTAINER, container);
  }
  #[inline]
  pub fn add_source_url(&mut self, source_url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_SOURCE_URL, source_url);
  }
  #[inline]
  pub fn add_start_time(&mut self, start_time: &Time) {
    self.fbb_.push_slot_always::<&Time>(MediaItem::VT_START_TIME, start_time);
  }
  #[inline]
  pub fn add_volume(&mut self, volume: f32) {
    self.fbb_.push_slot_always::<f32>(MediaItem::VT_VOLUME, volume);
  }
  #[inline]
  pub fn add_speed(&mut self, speed: f32) {
    self.fbb_.push_slot_always::<f32>(MediaItem::VT_SPEED, speed);
  }
  #[inline]
  pub fn add_headers(&mut self, headers: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<RequestHeader<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_HEADERS, headers);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_TITLE, title);
  }
  #[inline]
  pub fn add_thumbnail_url(&mut self, thumbnail_url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_THUMBNAIL_URL, thumbnail_url);
  }
  #[inline]
  pub fn add_metadata_type(&mut self, metadata_type: Metadata) {
    self.fbb_.push_slot::<Metadata>(MediaItem::VT_METADATA_TYPE, metadata_type, Metadata::NONE);
  }
  #[inline]
  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_METADATA, metadata);
  }
  #[inline]
  pub fn add_extra_metadata(&mut self, extra_metadata: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<MetadataKV<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaItem::VT_EXTRA_METADATA, extra_metadata);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MediaItemBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaItemBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MediaItem<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MediaItem::VT_CONTAINER,"container");
    self.fbb_.required(o, MediaItem::VT_SOURCE_URL,"source_url");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for MediaItem<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MediaItem");
      ds.field("container", &self.container());
      ds.field("source_url", &self.source_url());
      ds.field("start_time", &self.start_time());
      ds.field("volume", &self.volume());
      ds.field("speed", &self.speed());
      ds.field("headers", &self.headers());
      ds.field("title", &self.title());
      ds.field("thumbnail_url", &self.thumbnail_url());
      ds.field("metadata_type", &self.metadata_type());
      match self.metadata_type() {
        Metadata::Video => {
          if let Some(x) = self.metadata_as_video() {
            ds.field("metadata", &x)
          } else {
            ds.field("metadata", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Metadata::Audio => {
          if let Some(x) = self.metadata_as_audio() {
            ds.field("metadata", &x)
          } else {
            ds.field("metadata", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("metadata", &x)
        },
      };
      ds.field("extra_metadata", &self.extra_metadata());
      ds.finish()
  }
}
pub enum QueueItemOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> QueueItem<'a> {
  pub const VT_MEDIA_ITEM: ::flatbuffers::VOffsetT = 4;
  pub const VT_PLAYBACK_DURATION: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueItem { _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 QueueItemArgs<'args>
  ) -> ::flatbuffers::WIPOffset<QueueItem<'bldr>> {
    let mut builder = QueueItemBuilder::new(_fbb);
    if let Some(x) = args.playback_duration { builder.add_playback_duration(x); }
    if let Some(x) = args.media_item { builder.add_media_item(x); }
    builder.finish()
  }


  #[inline]
  pub fn media_item(&self) -> MediaItem<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<MediaItem>>(QueueItem::VT_MEDIA_ITEM, None).unwrap()}
  }
  #[inline]
  pub fn playback_duration(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(QueueItem::VT_PLAYBACK_DURATION, None)}
  }
}

impl ::flatbuffers::Verifiable for QueueItem<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<MediaItem>>("media_item", Self::VT_MEDIA_ITEM, true)?
     .visit_field::<Time>("playback_duration", Self::VT_PLAYBACK_DURATION, false)?
     .finish();
    Ok(())
  }
}
pub struct QueueItemArgs<'a> {
    pub media_item: Option<::flatbuffers::WIPOffset<MediaItem<'a>>>,
    pub playback_duration: Option<&'a Time>,
}
impl<'a> Default for QueueItemArgs<'a> {
  #[inline]
  fn default() -> Self {
    QueueItemArgs {
      media_item: None, // required field
      playback_duration: None,
    }
  }
}

pub struct QueueItemBuilder<'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> QueueItemBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_media_item(&mut self, media_item: ::flatbuffers::WIPOffset<MediaItem<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<MediaItem>>(QueueItem::VT_MEDIA_ITEM, media_item);
  }
  #[inline]
  pub fn add_playback_duration(&mut self, playback_duration: &Time) {
    self.fbb_.push_slot_always::<&Time>(QueueItem::VT_PLAYBACK_DURATION, playback_duration);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueItemBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueItemBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<QueueItem<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, QueueItem::VT_MEDIA_ITEM,"media_item");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Queue<'a> {
  pub const VT_ITEMS: ::flatbuffers::VOffsetT = 4;
  pub const VT_START_INDEX: ::flatbuffers::VOffsetT = 6;
  pub const VT_AUTOPLAY: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Queue { _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 QueueArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Queue<'bldr>> {
    let mut builder = QueueBuilder::new(_fbb);
    if let Some(x) = args.items { builder.add_items(x); }
    builder.add_autoplay(args.autoplay);
    if let Some(x) = args.start_index { builder.add_start_index(x); }
    builder.finish()
  }


  #[inline]
  pub fn items(&self) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<QueueItem<'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<QueueItem>>>>(Queue::VT_ITEMS, None).unwrap()}
  }
  #[inline]
  pub fn start_index(&self) -> Option<u8> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(Queue::VT_START_INDEX, None)}
  }
  #[inline]
  pub fn autoplay(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Queue::VT_AUTOPLAY, Some(false)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for Queue<'_> {
  #[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<QueueItem>>>>("items", Self::VT_ITEMS, true)?
     .visit_field::<u8>("start_index", Self::VT_START_INDEX, false)?
     .visit_field::<bool>("autoplay", Self::VT_AUTOPLAY, false)?
     .finish();
    Ok(())
  }
}
pub struct QueueArgs<'a> {
    pub items: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<QueueItem<'a>>>>>,
    pub start_index: Option<u8>,
    pub autoplay: bool,
}
impl<'a> Default for QueueArgs<'a> {
  #[inline]
  fn default() -> Self {
    QueueArgs {
      items: None, // required field
      start_index: None,
      autoplay: false,
    }
  }
}

pub struct QueueBuilder<'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> QueueBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_items(&mut self, items: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<QueueItem<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Queue::VT_ITEMS, items);
  }
  #[inline]
  pub fn add_start_index(&mut self, start_index: u8) {
    self.fbb_.push_slot_always::<u8>(Queue::VT_START_INDEX, start_index);
  }
  #[inline]
  pub fn add_autoplay(&mut self, autoplay: bool) {
    self.fbb_.push_slot::<bool>(Queue::VT_AUTOPLAY, autoplay, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Queue<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Queue::VT_ITEMS,"items");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> QueueIndex<'a> {
  pub const VT_INDEX: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueIndex { _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 QueueIndexArgs
  ) -> ::flatbuffers::WIPOffset<QueueIndex<'bldr>> {
    let mut builder = QueueIndexBuilder::new(_fbb);
    builder.add_index(args.index);
    builder.finish()
  }


  #[inline]
  pub fn index(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(QueueIndex::VT_INDEX, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for QueueIndex<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u8>("index", Self::VT_INDEX, false)?
     .finish();
    Ok(())
  }
}
pub struct QueueIndexArgs {
    pub index: u8,
}
impl<'a> Default for QueueIndexArgs {
  #[inline]
  fn default() -> Self {
    QueueIndexArgs {
      index: 0,
    }
  }
}

pub struct QueueIndexBuilder<'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> QueueIndexBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_index(&mut self, index: u8) {
    self.fbb_.push_slot::<u8>(QueueIndex::VT_INDEX, index, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueIndexBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueIndexBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<QueueIndex<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> QueueMarkerFront<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueMarkerFront { _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 QueueMarkerFrontArgs
  ) -> ::flatbuffers::WIPOffset<QueueMarkerFront<'bldr>> {
    let mut builder = QueueMarkerFrontBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for QueueMarkerFront<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct QueueMarkerFrontArgs {
}
impl<'a> Default for QueueMarkerFrontArgs {
  #[inline]
  fn default() -> Self {
    QueueMarkerFrontArgs {
    }
  }
}

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

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

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

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

impl<'a> QueueMarkerBack<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueMarkerBack { _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 QueueMarkerBackArgs
  ) -> ::flatbuffers::WIPOffset<QueueMarkerBack<'bldr>> {
    let mut builder = QueueMarkerBackBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for QueueMarkerBack<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct QueueMarkerBackArgs {
}
impl<'a> Default for QueueMarkerBackArgs {
  #[inline]
  fn default() -> Self {
    QueueMarkerBackArgs {
    }
  }
}

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

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

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

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

impl<'a> VideoTrackMeta<'a> {
  pub const VT_RESOLUTION: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn resolution(&self) -> Option<&'a VideoResolution> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<VideoResolution>(VideoTrackMeta::VT_RESOLUTION, None)}
  }
}

impl ::flatbuffers::Verifiable for VideoTrackMeta<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<VideoResolution>("resolution", Self::VT_RESOLUTION, false)?
     .finish();
    Ok(())
  }
}
pub struct VideoTrackMetaArgs<'a> {
    pub resolution: Option<&'a VideoResolution>,
}
impl<'a> Default for VideoTrackMetaArgs<'a> {
  #[inline]
  fn default() -> Self {
    VideoTrackMetaArgs {
      resolution: None,
    }
  }
}

pub struct VideoTrackMetaBuilder<'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> VideoTrackMetaBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_resolution(&mut self, resolution: &VideoResolution) {
    self.fbb_.push_slot_always::<&VideoResolution>(VideoTrackMeta::VT_RESOLUTION, resolution);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> VideoTrackMetaBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    VideoTrackMetaBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<VideoTrackMeta<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AudioTrackMeta<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AudioTrackMeta { _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 AudioTrackMetaArgs
  ) -> ::flatbuffers::WIPOffset<AudioTrackMeta<'bldr>> {
    let mut builder = AudioTrackMetaBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for AudioTrackMeta<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct AudioTrackMetaArgs {
}
impl<'a> Default for AudioTrackMetaArgs {
  #[inline]
  fn default() -> Self {
    AudioTrackMetaArgs {
    }
  }
}

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

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

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

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

impl<'a> SubtitleTrackMeta<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    SubtitleTrackMeta { _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 SubtitleTrackMetaArgs
  ) -> ::flatbuffers::WIPOffset<SubtitleTrackMeta<'bldr>> {
    let mut builder = SubtitleTrackMetaBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for SubtitleTrackMeta<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct SubtitleTrackMetaArgs {
}
impl<'a> Default for SubtitleTrackMetaArgs {
  #[inline]
  fn default() -> Self {
    SubtitleTrackMetaArgs {
    }
  }
}

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

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

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

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

impl<'a> DeviceInfo<'a> {
  pub const VT_DISPLAY_NAME: ::flatbuffers::VOffsetT = 4;
  pub const VT_APP_NAME: ::flatbuffers::VOffsetT = 6;
  pub const VT_APP_VERSION: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    DeviceInfo { _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 DeviceInfoArgs<'args>
  ) -> ::flatbuffers::WIPOffset<DeviceInfo<'bldr>> {
    let mut builder = DeviceInfoBuilder::new(_fbb);
    if let Some(x) = args.app_version { builder.add_app_version(x); }
    if let Some(x) = args.app_name { builder.add_app_name(x); }
    if let Some(x) = args.display_name { builder.add_display_name(x); }
    builder.finish()
  }


  #[inline]
  pub fn display_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>>(DeviceInfo::VT_DISPLAY_NAME, None)}
  }
  #[inline]
  pub fn app_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>>(DeviceInfo::VT_APP_NAME, None)}
  }
  #[inline]
  pub fn app_version(&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>>(DeviceInfo::VT_APP_VERSION, None)}
  }
}

impl ::flatbuffers::Verifiable for DeviceInfo<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("display_name", Self::VT_DISPLAY_NAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("app_name", Self::VT_APP_NAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("app_version", Self::VT_APP_VERSION, false)?
     .finish();
    Ok(())
  }
}
pub struct DeviceInfoArgs<'a> {
    pub display_name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub app_name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub app_version: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for DeviceInfoArgs<'a> {
  #[inline]
  fn default() -> Self {
    DeviceInfoArgs {
      display_name: None,
      app_name: None,
      app_version: None,
    }
  }
}

pub struct DeviceInfoBuilder<'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> DeviceInfoBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_display_name(&mut self, display_name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(DeviceInfo::VT_DISPLAY_NAME, display_name);
  }
  #[inline]
  pub fn add_app_name(&mut self, app_name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(DeviceInfo::VT_APP_NAME, app_name);
  }
  #[inline]
  pub fn add_app_version(&mut self, app_version: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(DeviceInfo::VT_APP_VERSION, app_version);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> DeviceInfoBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    DeviceInfoBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<DeviceInfo<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> DisplayCapabilities<'a> {
  pub const VT_RESOLUTION: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn resolution(&self) -> Option<&'a VideoResolution> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<VideoResolution>(DisplayCapabilities::VT_RESOLUTION, None)}
  }
}

impl ::flatbuffers::Verifiable for DisplayCapabilities<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<VideoResolution>("resolution", Self::VT_RESOLUTION, false)?
     .finish();
    Ok(())
  }
}
pub struct DisplayCapabilitiesArgs<'a> {
    pub resolution: Option<&'a VideoResolution>,
}
impl<'a> Default for DisplayCapabilitiesArgs<'a> {
  #[inline]
  fn default() -> Self {
    DisplayCapabilitiesArgs {
      resolution: None,
    }
  }
}

pub struct DisplayCapabilitiesBuilder<'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> DisplayCapabilitiesBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_resolution(&mut self, resolution: &VideoResolution) {
    self.fbb_.push_slot_always::<&VideoResolution>(DisplayCapabilities::VT_RESOLUTION, resolution);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> DisplayCapabilitiesBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    DisplayCapabilitiesBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<DisplayCapabilities<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> MediaCapabilities<'a> {
  pub const VT_PROTOCOLS: ::flatbuffers::VOffsetT = 4;
  pub const VT_CONTAINERS: ::flatbuffers::VOffsetT = 6;
  pub const VT_VIDEO_FORMATS: ::flatbuffers::VOffsetT = 8;
  pub const VT_AUDIO_FORMATS: ::flatbuffers::VOffsetT = 10;
  pub const VT_SUBTITLE_FORMATS: ::flatbuffers::VOffsetT = 12;
  pub const VT_HDR_FORMATS: ::flatbuffers::VOffsetT = 14;
  pub const VT_IMAGE_FORMATS: ::flatbuffers::VOffsetT = 16;
  pub const VT_EXTERNAL_SUBTITLES: ::flatbuffers::VOffsetT = 18;
  pub const VT_MIRRORING: ::flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MediaCapabilities { _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 MediaCapabilitiesArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MediaCapabilities<'bldr>> {
    let mut builder = MediaCapabilitiesBuilder::new(_fbb);
    if let Some(x) = args.image_formats { builder.add_image_formats(x); }
    if let Some(x) = args.hdr_formats { builder.add_hdr_formats(x); }
    if let Some(x) = args.subtitle_formats { builder.add_subtitle_formats(x); }
    if let Some(x) = args.audio_formats { builder.add_audio_formats(x); }
    if let Some(x) = args.video_formats { builder.add_video_formats(x); }
    if let Some(x) = args.containers { builder.add_containers(x); }
    if let Some(x) = args.protocols { builder.add_protocols(x); }
    builder.add_mirroring(args.mirroring);
    builder.add_external_subtitles(args.external_subtitles);
    builder.finish()
  }


  #[inline]
  pub fn protocols(&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>>>>(MediaCapabilities::VT_PROTOCOLS, None)}
  }
  #[inline]
  pub fn containers(&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>>>>(MediaCapabilities::VT_CONTAINERS, None)}
  }
  #[inline]
  pub fn video_formats(&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>>>>(MediaCapabilities::VT_VIDEO_FORMATS, None)}
  }
  #[inline]
  pub fn audio_formats(&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>>>>(MediaCapabilities::VT_AUDIO_FORMATS, None)}
  }
  #[inline]
  pub fn subtitle_formats(&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>>>>(MediaCapabilities::VT_SUBTITLE_FORMATS, None)}
  }
  #[inline]
  pub fn hdr_formats(&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>>>>(MediaCapabilities::VT_HDR_FORMATS, None)}
  }
  #[inline]
  pub fn image_formats(&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>>>>(MediaCapabilities::VT_IMAGE_FORMATS, None)}
  }
  #[inline]
  pub fn external_subtitles(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(MediaCapabilities::VT_EXTERNAL_SUBTITLES, Some(false)).unwrap()}
  }
  #[inline]
  pub fn mirroring(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(MediaCapabilities::VT_MIRRORING, Some(false)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for MediaCapabilities<'_> {
  #[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<&'_ str>>>>("protocols", Self::VT_PROTOCOLS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("containers", Self::VT_CONTAINERS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("video_formats", Self::VT_VIDEO_FORMATS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("audio_formats", Self::VT_AUDIO_FORMATS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("subtitle_formats", Self::VT_SUBTITLE_FORMATS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("hdr_formats", Self::VT_HDR_FORMATS, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("image_formats", Self::VT_IMAGE_FORMATS, false)?
     .visit_field::<bool>("external_subtitles", Self::VT_EXTERNAL_SUBTITLES, false)?
     .visit_field::<bool>("mirroring", Self::VT_MIRRORING, false)?
     .finish();
    Ok(())
  }
}
pub struct MediaCapabilitiesArgs<'a> {
    pub protocols: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub containers: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub video_formats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub audio_formats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub subtitle_formats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub hdr_formats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub image_formats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub external_subtitles: bool,
    pub mirroring: bool,
}
impl<'a> Default for MediaCapabilitiesArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaCapabilitiesArgs {
      protocols: None,
      containers: None,
      video_formats: None,
      audio_formats: None,
      subtitle_formats: None,
      hdr_formats: None,
      image_formats: None,
      external_subtitles: false,
      mirroring: false,
    }
  }
}

pub struct MediaCapabilitiesBuilder<'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> MediaCapabilitiesBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_protocols(&mut self, protocols: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_PROTOCOLS, protocols);
  }
  #[inline]
  pub fn add_containers(&mut self, containers: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_CONTAINERS, containers);
  }
  #[inline]
  pub fn add_video_formats(&mut self, video_formats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_VIDEO_FORMATS, video_formats);
  }
  #[inline]
  pub fn add_audio_formats(&mut self, audio_formats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_AUDIO_FORMATS, audio_formats);
  }
  #[inline]
  pub fn add_subtitle_formats(&mut self, subtitle_formats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_SUBTITLE_FORMATS, subtitle_formats);
  }
  #[inline]
  pub fn add_hdr_formats(&mut self, hdr_formats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_HDR_FORMATS, hdr_formats);
  }
  #[inline]
  pub fn add_image_formats(&mut self, image_formats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaCapabilities::VT_IMAGE_FORMATS, image_formats);
  }
  #[inline]
  pub fn add_external_subtitles(&mut self, external_subtitles: bool) {
    self.fbb_.push_slot::<bool>(MediaCapabilities::VT_EXTERNAL_SUBTITLES, external_subtitles, false);
  }
  #[inline]
  pub fn add_mirroring(&mut self, mirroring: bool) {
    self.fbb_.push_slot::<bool>(MediaCapabilities::VT_MIRRORING, mirroring, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MediaCapabilitiesBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaCapabilitiesBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MediaCapabilities<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for MediaCapabilities<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MediaCapabilities");
      ds.field("protocols", &self.protocols());
      ds.field("containers", &self.containers());
      ds.field("video_formats", &self.video_formats());
      ds.field("audio_formats", &self.audio_formats());
      ds.field("subtitle_formats", &self.subtitle_formats());
      ds.field("hdr_formats", &self.hdr_formats());
      ds.field("image_formats", &self.image_formats());
      ds.field("external_subtitles", &self.external_subtitles());
      ds.field("mirroring", &self.mirroring());
      ds.finish()
  }
}
pub enum AudioCapabilitiesOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> AudioCapabilities<'a> {
  pub const VT_VOLUME_STEP_INTERVAL: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AudioCapabilities { _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 AudioCapabilitiesArgs
  ) -> ::flatbuffers::WIPOffset<AudioCapabilities<'bldr>> {
    let mut builder = AudioCapabilitiesBuilder::new(_fbb);
    builder.add_volume_step_interval(args.volume_step_interval);
    builder.finish()
  }


  #[inline]
  pub fn volume_step_interval(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(AudioCapabilities::VT_VOLUME_STEP_INTERVAL, Some(0.0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for AudioCapabilities<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<f32>("volume_step_interval", Self::VT_VOLUME_STEP_INTERVAL, false)?
     .finish();
    Ok(())
  }
}
pub struct AudioCapabilitiesArgs {
    pub volume_step_interval: f32,
}
impl<'a> Default for AudioCapabilitiesArgs {
  #[inline]
  fn default() -> Self {
    AudioCapabilitiesArgs {
      volume_step_interval: 0.0,
    }
  }
}

pub struct AudioCapabilitiesBuilder<'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> AudioCapabilitiesBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_volume_step_interval(&mut self, volume_step_interval: f32) {
    self.fbb_.push_slot::<f32>(AudioCapabilities::VT_VOLUME_STEP_INTERVAL, volume_step_interval, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AudioCapabilitiesBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AudioCapabilitiesBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AudioCapabilities<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ReceiverCapabilities<'a> {
  pub const VT_MEDIA: ::flatbuffers::VOffsetT = 4;
  pub const VT_DISPLAY: ::flatbuffers::VOffsetT = 6;
  pub const VT_AUDIO: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ReceiverCapabilities { _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 ReceiverCapabilitiesArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ReceiverCapabilities<'bldr>> {
    let mut builder = ReceiverCapabilitiesBuilder::new(_fbb);
    if let Some(x) = args.audio { builder.add_audio(x); }
    if let Some(x) = args.display { builder.add_display(x); }
    if let Some(x) = args.media { builder.add_media(x); }
    builder.finish()
  }


  #[inline]
  pub fn media(&self) -> Option<MediaCapabilities<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<MediaCapabilities>>(ReceiverCapabilities::VT_MEDIA, None)}
  }
  #[inline]
  pub fn display(&self) -> Option<DisplayCapabilities<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<DisplayCapabilities>>(ReceiverCapabilities::VT_DISPLAY, None)}
  }
  #[inline]
  pub fn audio(&self) -> Option<AudioCapabilities<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<AudioCapabilities>>(ReceiverCapabilities::VT_AUDIO, None)}
  }
}

impl ::flatbuffers::Verifiable for ReceiverCapabilities<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<MediaCapabilities>>("media", Self::VT_MEDIA, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<DisplayCapabilities>>("display", Self::VT_DISPLAY, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<AudioCapabilities>>("audio", Self::VT_AUDIO, false)?
     .finish();
    Ok(())
  }
}
pub struct ReceiverCapabilitiesArgs<'a> {
    pub media: Option<::flatbuffers::WIPOffset<MediaCapabilities<'a>>>,
    pub display: Option<::flatbuffers::WIPOffset<DisplayCapabilities<'a>>>,
    pub audio: Option<::flatbuffers::WIPOffset<AudioCapabilities<'a>>>,
}
impl<'a> Default for ReceiverCapabilitiesArgs<'a> {
  #[inline]
  fn default() -> Self {
    ReceiverCapabilitiesArgs {
      media: None,
      display: None,
      audio: None,
    }
  }
}

pub struct ReceiverCapabilitiesBuilder<'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> ReceiverCapabilitiesBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_media(&mut self, media: ::flatbuffers::WIPOffset<MediaCapabilities<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<MediaCapabilities>>(ReceiverCapabilities::VT_MEDIA, media);
  }
  #[inline]
  pub fn add_display(&mut self, display: ::flatbuffers::WIPOffset<DisplayCapabilities<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<DisplayCapabilities>>(ReceiverCapabilities::VT_DISPLAY, display);
  }
  #[inline]
  pub fn add_audio(&mut self, audio: ::flatbuffers::WIPOffset<AudioCapabilities<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<AudioCapabilities>>(ReceiverCapabilities::VT_AUDIO, audio);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ReceiverCapabilitiesBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ReceiverCapabilitiesBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ReceiverCapabilities<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> MediaTrack<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_ISO_639: ::flatbuffers::VOffsetT = 6;
  pub const VT_TITLE: ::flatbuffers::VOffsetT = 8;
  pub const VT_METADATA_TYPE: ::flatbuffers::VOffsetT = 10;
  pub const VT_METADATA: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MediaTrack { _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 MediaTrackArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MediaTrack<'bldr>> {
    let mut builder = MediaTrackBuilder::new(_fbb);
    if let Some(x) = args.metadata { builder.add_metadata(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    if let Some(x) = args.iso_639 { builder.add_iso_639(x); }
    builder.add_id(args.id);
    builder.add_metadata_type(args.metadata_type);
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(MediaTrack::VT_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn iso_639(&self) -> &'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>>(MediaTrack::VT_ISO_639, None).unwrap()}
  }
  #[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>>(MediaTrack::VT_TITLE, None)}
  }
  #[inline]
  pub fn metadata_type(&self) -> MediaTrackMetadata {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaTrackMetadata>(MediaTrack::VT_METADATA_TYPE, Some(MediaTrackMetadata::NONE)).unwrap()}
  }
  #[inline]
  pub fn metadata(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(MediaTrack::VT_METADATA, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn metadata_as_video(&self) -> Option<VideoTrackMeta<'a>> {
    if self.metadata_type() == MediaTrackMetadata::Video {
      self.metadata().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { VideoTrackMeta::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn metadata_as_audio(&self) -> Option<AudioTrackMeta<'a>> {
    if self.metadata_type() == MediaTrackMetadata::Audio {
      self.metadata().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { AudioTrackMeta::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn metadata_as_subtitle(&self) -> Option<SubtitleTrackMeta<'a>> {
    if self.metadata_type() == MediaTrackMetadata::Subtitle {
      self.metadata().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { SubtitleTrackMeta::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for MediaTrack<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u32>("id", Self::VT_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("iso_639", Self::VT_ISO_639, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_union::<MediaTrackMetadata, _>("metadata_type", Self::VT_METADATA_TYPE, "metadata", Self::VT_METADATA, false, |key, v, pos| {
        match key {
          MediaTrackMetadata::Video => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<VideoTrackMeta>>("MediaTrackMetadata::Video", pos),
          MediaTrackMetadata::Audio => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AudioTrackMeta>>("MediaTrackMetadata::Audio", pos),
          MediaTrackMetadata::Subtitle => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<SubtitleTrackMeta>>("MediaTrackMetadata::Subtitle", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct MediaTrackArgs<'a> {
    pub id: u32,
    pub iso_639: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub title: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub metadata_type: MediaTrackMetadata,
    pub metadata: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for MediaTrackArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaTrackArgs {
      id: 0,
      iso_639: None, // required field
      title: None,
      metadata_type: MediaTrackMetadata::NONE,
      metadata: None,
    }
  }
}

pub struct MediaTrackBuilder<'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> MediaTrackBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: u32) {
    self.fbb_.push_slot::<u32>(MediaTrack::VT_ID, id, 0);
  }
  #[inline]
  pub fn add_iso_639(&mut self, iso_639: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaTrack::VT_ISO_639, iso_639);
  }
  #[inline]
  pub fn add_title(&mut self, title: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaTrack::VT_TITLE, title);
  }
  #[inline]
  pub fn add_metadata_type(&mut self, metadata_type: MediaTrackMetadata) {
    self.fbb_.push_slot::<MediaTrackMetadata>(MediaTrack::VT_METADATA_TYPE, metadata_type, MediaTrackMetadata::NONE);
  }
  #[inline]
  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MediaTrack::VT_METADATA, metadata);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MediaTrackBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaTrackBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MediaTrack<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MediaTrack::VT_ISO_639,"iso_639");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for MediaTrack<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("MediaTrack");
      ds.field("id", &self.id());
      ds.field("iso_639", &self.iso_639());
      ds.field("title", &self.title());
      ds.field("metadata_type", &self.metadata_type());
      match self.metadata_type() {
        MediaTrackMetadata::Video => {
          if let Some(x) = self.metadata_as_video() {
            ds.field("metadata", &x)
          } else {
            ds.field("metadata", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        MediaTrackMetadata::Audio => {
          if let Some(x) = self.metadata_as_audio() {
            ds.field("metadata", &x)
          } else {
            ds.field("metadata", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        MediaTrackMetadata::Subtitle => {
          if let Some(x) = self.metadata_as_subtitle() {
            ds.field("metadata", &x)
          } else {
            ds.field("metadata", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("metadata", &x)
        },
      };
      ds.finish()
  }
}
pub enum ProgressChangedOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ProgressChanged<'a> {
  pub const VT_POSITION: ::flatbuffers::VOffsetT = 4;
  pub const VT_DURATION: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ProgressChanged { _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 ProgressChangedArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ProgressChanged<'bldr>> {
    let mut builder = ProgressChangedBuilder::new(_fbb);
    if let Some(x) = args.duration { builder.add_duration(x); }
    if let Some(x) = args.position { builder.add_position(x); }
    builder.finish()
  }


  #[inline]
  pub fn position(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(ProgressChanged::VT_POSITION, None)}
  }
  #[inline]
  pub fn duration(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(ProgressChanged::VT_DURATION, None)}
  }
}

impl ::flatbuffers::Verifiable for ProgressChanged<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Time>("position", Self::VT_POSITION, false)?
     .visit_field::<Time>("duration", Self::VT_DURATION, false)?
     .finish();
    Ok(())
  }
}
pub struct ProgressChangedArgs<'a> {
    pub position: Option<&'a Time>,
    pub duration: Option<&'a Time>,
}
impl<'a> Default for ProgressChangedArgs<'a> {
  #[inline]
  fn default() -> Self {
    ProgressChangedArgs {
      position: None,
      duration: None,
    }
  }
}

pub struct ProgressChangedBuilder<'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> ProgressChangedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_position(&mut self, position: &Time) {
    self.fbb_.push_slot_always::<&Time>(ProgressChanged::VT_POSITION, position);
  }
  #[inline]
  pub fn add_duration(&mut self, duration: &Time) {
    self.fbb_.push_slot_always::<&Time>(ProgressChanged::VT_DURATION, duration);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ProgressChangedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ProgressChangedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ProgressChanged<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

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

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


  #[inline]
  pub fn source_type(&self) -> MediaSource {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaSource>(Load::VT_SOURCE_TYPE, Some(MediaSource::NONE)).unwrap()}
  }
  #[inline]
  pub fn source(&self) -> ::flatbuffers::Table<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Load::VT_SOURCE, None).unwrap()}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn source_as_single(&self) -> Option<MediaItem<'a>> {
    if self.source_type() == MediaSource::Single {
      let u = self.source();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { MediaItem::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn source_as_queue(&self) -> Option<Queue<'a>> {
    if self.source_type() == MediaSource::Queue {
      let u = self.source();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { Queue::init_from_table(u) })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for Load<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<MediaSource, _>("source_type", Self::VT_SOURCE_TYPE, "source", Self::VT_SOURCE, true, |key, v, pos| {
        match key {
          MediaSource::Single => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<MediaItem>>("MediaSource::Single", pos),
          MediaSource::Queue => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Queue>>("MediaSource::Queue", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct LoadArgs {
    pub source_type: MediaSource,
    pub source: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for LoadArgs {
  #[inline]
  fn default() -> Self {
    LoadArgs {
      source_type: MediaSource::NONE,
      source: None, // required field
    }
  }
}

pub struct LoadBuilder<'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> LoadBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_source_type(&mut self, source_type: MediaSource) {
    self.fbb_.push_slot::<MediaSource>(Load::VT_SOURCE_TYPE, source_type, MediaSource::NONE);
  }
  #[inline]
  pub fn add_source(&mut self, source: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Load::VT_SOURCE, source);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> LoadBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    LoadBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Load<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Load::VT_SOURCE,"source");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Load<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Load");
      ds.field("source_type", &self.source_type());
      match self.source_type() {
        MediaSource::Single => {
          if let Some(x) = self.source_as_single() {
            ds.field("source", &x)
          } else {
            ds.field("source", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        MediaSource::Queue => {
          if let Some(x) = self.source_as_queue() {
            ds.field("source", &x)
          } else {
            ds.field("source", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("source", &x)
        },
      };
      ds.finish()
  }
}
pub enum QueueInsertOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> QueueInsert<'a> {
  pub const VT_ITEM: ::flatbuffers::VOffsetT = 4;
  pub const VT_POSITION_TYPE: ::flatbuffers::VOffsetT = 6;
  pub const VT_POSITION: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueInsert { _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 QueueInsertArgs<'args>
  ) -> ::flatbuffers::WIPOffset<QueueInsert<'bldr>> {
    let mut builder = QueueInsertBuilder::new(_fbb);
    if let Some(x) = args.position { builder.add_position(x); }
    if let Some(x) = args.item { builder.add_item(x); }
    builder.add_position_type(args.position_type);
    builder.finish()
  }


  #[inline]
  pub fn item(&self) -> QueueItem<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<QueueItem>>(QueueInsert::VT_ITEM, None).unwrap()}
  }
  #[inline]
  pub fn position_type(&self) -> QueuePosition {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<QueuePosition>(QueueInsert::VT_POSITION_TYPE, Some(QueuePosition::NONE)).unwrap()}
  }
  #[inline]
  pub fn position(&self) -> ::flatbuffers::Table<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(QueueInsert::VT_POSITION, None).unwrap()}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_index(&self) -> Option<QueueIndex<'a>> {
    if self.position_type() == QueuePosition::Index {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueIndex::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_front(&self) -> Option<QueueMarkerFront<'a>> {
    if self.position_type() == QueuePosition::Front {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerFront::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_back(&self) -> Option<QueueMarkerBack<'a>> {
    if self.position_type() == QueuePosition::Back {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerBack::init_from_table(u) })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for QueueInsert<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<QueueItem>>("item", Self::VT_ITEM, true)?
     .visit_union::<QueuePosition, _>("position_type", Self::VT_POSITION_TYPE, "position", Self::VT_POSITION, true, |key, v, pos| {
        match key {
          QueuePosition::Index => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueIndex>>("QueuePosition::Index", pos),
          QueuePosition::Front => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerFront>>("QueuePosition::Front", pos),
          QueuePosition::Back => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerBack>>("QueuePosition::Back", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct QueueInsertArgs<'a> {
    pub item: Option<::flatbuffers::WIPOffset<QueueItem<'a>>>,
    pub position_type: QueuePosition,
    pub position: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for QueueInsertArgs<'a> {
  #[inline]
  fn default() -> Self {
    QueueInsertArgs {
      item: None, // required field
      position_type: QueuePosition::NONE,
      position: None, // required field
    }
  }
}

pub struct QueueInsertBuilder<'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> QueueInsertBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_item(&mut self, item: ::flatbuffers::WIPOffset<QueueItem<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<QueueItem>>(QueueInsert::VT_ITEM, item);
  }
  #[inline]
  pub fn add_position_type(&mut self, position_type: QueuePosition) {
    self.fbb_.push_slot::<QueuePosition>(QueueInsert::VT_POSITION_TYPE, position_type, QueuePosition::NONE);
  }
  #[inline]
  pub fn add_position(&mut self, position: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(QueueInsert::VT_POSITION, position);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueInsertBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueInsertBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<QueueInsert<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, QueueInsert::VT_ITEM,"item");
    self.fbb_.required(o, QueueInsert::VT_POSITION,"position");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for QueueInsert<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("QueueInsert");
      ds.field("item", &self.item());
      ds.field("position_type", &self.position_type());
      match self.position_type() {
        QueuePosition::Index => {
          if let Some(x) = self.position_as_index() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Front => {
          if let Some(x) = self.position_as_front() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Back => {
          if let Some(x) = self.position_as_back() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("position", &x)
        },
      };
      ds.finish()
  }
}
pub enum QueueRemoveOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> QueueRemove<'a> {
  pub const VT_POSITION_TYPE: ::flatbuffers::VOffsetT = 4;
  pub const VT_POSITION: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueRemove { _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 QueueRemoveArgs
  ) -> ::flatbuffers::WIPOffset<QueueRemove<'bldr>> {
    let mut builder = QueueRemoveBuilder::new(_fbb);
    if let Some(x) = args.position { builder.add_position(x); }
    builder.add_position_type(args.position_type);
    builder.finish()
  }


  #[inline]
  pub fn position_type(&self) -> QueuePosition {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<QueuePosition>(QueueRemove::VT_POSITION_TYPE, Some(QueuePosition::NONE)).unwrap()}
  }
  #[inline]
  pub fn position(&self) -> ::flatbuffers::Table<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(QueueRemove::VT_POSITION, None).unwrap()}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_index(&self) -> Option<QueueIndex<'a>> {
    if self.position_type() == QueuePosition::Index {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueIndex::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_front(&self) -> Option<QueueMarkerFront<'a>> {
    if self.position_type() == QueuePosition::Front {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerFront::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_back(&self) -> Option<QueueMarkerBack<'a>> {
    if self.position_type() == QueuePosition::Back {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerBack::init_from_table(u) })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for QueueRemove<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<QueuePosition, _>("position_type", Self::VT_POSITION_TYPE, "position", Self::VT_POSITION, true, |key, v, pos| {
        match key {
          QueuePosition::Index => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueIndex>>("QueuePosition::Index", pos),
          QueuePosition::Front => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerFront>>("QueuePosition::Front", pos),
          QueuePosition::Back => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerBack>>("QueuePosition::Back", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct QueueRemoveArgs {
    pub position_type: QueuePosition,
    pub position: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for QueueRemoveArgs {
  #[inline]
  fn default() -> Self {
    QueueRemoveArgs {
      position_type: QueuePosition::NONE,
      position: None, // required field
    }
  }
}

pub struct QueueRemoveBuilder<'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> QueueRemoveBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_position_type(&mut self, position_type: QueuePosition) {
    self.fbb_.push_slot::<QueuePosition>(QueueRemove::VT_POSITION_TYPE, position_type, QueuePosition::NONE);
  }
  #[inline]
  pub fn add_position(&mut self, position: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(QueueRemove::VT_POSITION, position);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueRemoveBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueRemoveBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<QueueRemove<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, QueueRemove::VT_POSITION,"position");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for QueueRemove<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("QueueRemove");
      ds.field("position_type", &self.position_type());
      match self.position_type() {
        QueuePosition::Index => {
          if let Some(x) = self.position_as_index() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Front => {
          if let Some(x) = self.position_as_front() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Back => {
          if let Some(x) = self.position_as_back() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("position", &x)
        },
      };
      ds.finish()
  }
}
pub enum QueueItemSelectedOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> QueueItemSelected<'a> {
  pub const VT_POSITION_TYPE: ::flatbuffers::VOffsetT = 4;
  pub const VT_POSITION: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    QueueItemSelected { _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 QueueItemSelectedArgs
  ) -> ::flatbuffers::WIPOffset<QueueItemSelected<'bldr>> {
    let mut builder = QueueItemSelectedBuilder::new(_fbb);
    if let Some(x) = args.position { builder.add_position(x); }
    builder.add_position_type(args.position_type);
    builder.finish()
  }


  #[inline]
  pub fn position_type(&self) -> QueuePosition {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<QueuePosition>(QueueItemSelected::VT_POSITION_TYPE, Some(QueuePosition::NONE)).unwrap()}
  }
  #[inline]
  pub fn position(&self) -> ::flatbuffers::Table<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(QueueItemSelected::VT_POSITION, None).unwrap()}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_index(&self) -> Option<QueueIndex<'a>> {
    if self.position_type() == QueuePosition::Index {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueIndex::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_front(&self) -> Option<QueueMarkerFront<'a>> {
    if self.position_type() == QueuePosition::Front {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerFront::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn position_as_back(&self) -> Option<QueueMarkerBack<'a>> {
    if self.position_type() == QueuePosition::Back {
      let u = self.position();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { QueueMarkerBack::init_from_table(u) })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for QueueItemSelected<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<QueuePosition, _>("position_type", Self::VT_POSITION_TYPE, "position", Self::VT_POSITION, true, |key, v, pos| {
        match key {
          QueuePosition::Index => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueIndex>>("QueuePosition::Index", pos),
          QueuePosition::Front => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerFront>>("QueuePosition::Front", pos),
          QueuePosition::Back => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<QueueMarkerBack>>("QueuePosition::Back", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct QueueItemSelectedArgs {
    pub position_type: QueuePosition,
    pub position: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for QueueItemSelectedArgs {
  #[inline]
  fn default() -> Self {
    QueueItemSelectedArgs {
      position_type: QueuePosition::NONE,
      position: None, // required field
    }
  }
}

pub struct QueueItemSelectedBuilder<'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> QueueItemSelectedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_position_type(&mut self, position_type: QueuePosition) {
    self.fbb_.push_slot::<QueuePosition>(QueueItemSelected::VT_POSITION_TYPE, position_type, QueuePosition::NONE);
  }
  #[inline]
  pub fn add_position(&mut self, position: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(QueueItemSelected::VT_POSITION, position);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> QueueItemSelectedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    QueueItemSelectedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<QueueItemSelected<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, QueueItemSelected::VT_POSITION,"position");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for QueueItemSelected<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("QueueItemSelected");
      ds.field("position_type", &self.position_type());
      match self.position_type() {
        QueuePosition::Index => {
          if let Some(x) = self.position_as_index() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Front => {
          if let Some(x) = self.position_as_front() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        QueuePosition::Back => {
          if let Some(x) = self.position_as_back() {
            ds.field("position", &x)
          } else {
            ds.field("position", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("position", &x)
        },
      };
      ds.finish()
  }
}
pub enum TracksAvailableOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> TracksAvailable<'a> {
  pub const VT_TRACKS: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn tracks(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaTrack<'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<MediaTrack>>>>(TracksAvailable::VT_TRACKS, None)}
  }
}

impl ::flatbuffers::Verifiable for TracksAvailable<'_> {
  #[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<MediaTrack>>>>("tracks", Self::VT_TRACKS, false)?
     .finish();
    Ok(())
  }
}
pub struct TracksAvailableArgs<'a> {
    pub tracks: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<MediaTrack<'a>>>>>,
}
impl<'a> Default for TracksAvailableArgs<'a> {
  #[inline]
  fn default() -> Self {
    TracksAvailableArgs {
      tracks: None,
    }
  }
}

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

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

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

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

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

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


  #[inline]
  pub fn id(&self) -> Option<u32> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(ChangeTrack::VT_ID, None)}
  }
  #[inline]
  pub fn track_type(&self) -> MediaTrackType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaTrackType>(ChangeTrack::VT_TRACK_TYPE, Some(MediaTrackType::Video)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for ChangeTrack<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u32>("id", Self::VT_ID, false)?
     .visit_field::<MediaTrackType>("track_type", Self::VT_TRACK_TYPE, false)?
     .finish();
    Ok(())
  }
}
pub struct ChangeTrackArgs {
    pub id: Option<u32>,
    pub track_type: MediaTrackType,
}
impl<'a> Default for ChangeTrackArgs {
  #[inline]
  fn default() -> Self {
    ChangeTrackArgs {
      id: None,
      track_type: MediaTrackType::Video,
    }
  }
}

pub struct ChangeTrackBuilder<'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> ChangeTrackBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: u32) {
    self.fbb_.push_slot_always::<u32>(ChangeTrack::VT_ID, id);
  }
  #[inline]
  pub fn add_track_type(&mut self, track_type: MediaTrackType) {
    self.fbb_.push_slot::<MediaTrackType>(ChangeTrack::VT_TRACK_TYPE, track_type, MediaTrackType::Video);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ChangeTrackBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ChangeTrackBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ChangeTrack<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SenderIntroduction<'a> {
  pub const VT_DEVICE_INFO: ::flatbuffers::VOffsetT = 4;

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


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

impl ::flatbuffers::Verifiable for SenderIntroduction<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<DeviceInfo>>("device_info", Self::VT_DEVICE_INFO, true)?
     .finish();
    Ok(())
  }
}
pub struct SenderIntroductionArgs<'a> {
    pub device_info: Option<::flatbuffers::WIPOffset<DeviceInfo<'a>>>,
}
impl<'a> Default for SenderIntroductionArgs<'a> {
  #[inline]
  fn default() -> Self {
    SenderIntroductionArgs {
      device_info: None, // required field
    }
  }
}

pub struct SenderIntroductionBuilder<'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> SenderIntroductionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_device_info(&mut self, device_info: ::flatbuffers::WIPOffset<DeviceInfo<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<DeviceInfo>>(SenderIntroduction::VT_DEVICE_INFO, device_info);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SenderIntroductionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SenderIntroductionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<SenderIntroduction<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SenderIntroduction::VT_DEVICE_INFO,"device_info");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ReceiverIntroduction<'a> {
  pub const VT_DEVICE_INFO: ::flatbuffers::VOffsetT = 4;
  pub const VT_CAPABILITIES: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    ReceiverIntroduction { _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 ReceiverIntroductionArgs<'args>
  ) -> ::flatbuffers::WIPOffset<ReceiverIntroduction<'bldr>> {
    let mut builder = ReceiverIntroductionBuilder::new(_fbb);
    if let Some(x) = args.capabilities { builder.add_capabilities(x); }
    if let Some(x) = args.device_info { builder.add_device_info(x); }
    builder.finish()
  }


  #[inline]
  pub fn device_info(&self) -> DeviceInfo<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<DeviceInfo>>(ReceiverIntroduction::VT_DEVICE_INFO, None).unwrap()}
  }
  #[inline]
  pub fn capabilities(&self) -> Option<ReceiverCapabilities<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<ReceiverCapabilities>>(ReceiverIntroduction::VT_CAPABILITIES, None)}
  }
}

impl ::flatbuffers::Verifiable for ReceiverIntroduction<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<DeviceInfo>>("device_info", Self::VT_DEVICE_INFO, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<ReceiverCapabilities>>("capabilities", Self::VT_CAPABILITIES, false)?
     .finish();
    Ok(())
  }
}
pub struct ReceiverIntroductionArgs<'a> {
    pub device_info: Option<::flatbuffers::WIPOffset<DeviceInfo<'a>>>,
    pub capabilities: Option<::flatbuffers::WIPOffset<ReceiverCapabilities<'a>>>,
}
impl<'a> Default for ReceiverIntroductionArgs<'a> {
  #[inline]
  fn default() -> Self {
    ReceiverIntroductionArgs {
      device_info: None, // required field
      capabilities: None,
    }
  }
}

pub struct ReceiverIntroductionBuilder<'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> ReceiverIntroductionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_device_info(&mut self, device_info: ::flatbuffers::WIPOffset<DeviceInfo<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<DeviceInfo>>(ReceiverIntroduction::VT_DEVICE_INFO, device_info);
  }
  #[inline]
  pub fn add_capabilities(&mut self, capabilities: ::flatbuffers::WIPOffset<ReceiverCapabilities<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<ReceiverCapabilities>>(ReceiverIntroduction::VT_CAPABILITIES, capabilities);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ReceiverIntroductionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ReceiverIntroductionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<ReceiverIntroduction<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ReceiverIntroduction::VT_DEVICE_INFO,"device_info");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SpeedChanged<'a> {
  pub const VT_SPEED: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    SpeedChanged { _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 SpeedChangedArgs
  ) -> ::flatbuffers::WIPOffset<SpeedChanged<'bldr>> {
    let mut builder = SpeedChangedBuilder::new(_fbb);
    builder.add_speed(args.speed);
    builder.finish()
  }


  #[inline]
  pub fn speed(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(SpeedChanged::VT_SPEED, Some(0.0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for SpeedChanged<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<f32>("speed", Self::VT_SPEED, false)?
     .finish();
    Ok(())
  }
}
pub struct SpeedChangedArgs {
    pub speed: f32,
}
impl<'a> Default for SpeedChangedArgs {
  #[inline]
  fn default() -> Self {
    SpeedChangedArgs {
      speed: 0.0,
    }
  }
}

pub struct SpeedChangedBuilder<'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> SpeedChangedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_speed(&mut self, speed: f32) {
    self.fbb_.push_slot::<f32>(SpeedChanged::VT_SPEED, speed, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SpeedChangedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SpeedChangedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<SpeedChanged<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AddSubtitleSource<'a> {
  pub const VT_URL: ::flatbuffers::VOffsetT = 4;
  pub const VT_SELECT: ::flatbuffers::VOffsetT = 6;
  pub const VT_NAME: ::flatbuffers::VOffsetT = 8;
  pub const VT_METADATA: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AddSubtitleSource { _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 AddSubtitleSourceArgs<'args>
  ) -> ::flatbuffers::WIPOffset<AddSubtitleSource<'bldr>> {
    let mut builder = AddSubtitleSourceBuilder::new(_fbb);
    if let Some(x) = args.metadata { builder.add_metadata(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    builder.add_select(args.select);
    builder.finish()
  }


  #[inline]
  pub fn url(&self) -> &'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>>(AddSubtitleSource::VT_URL, None).unwrap()}
  }
  #[inline]
  pub fn select(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(AddSubtitleSource::VT_SELECT, Some(false)).unwrap()}
  }
  #[inline]
  pub fn name(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(AddSubtitleSource::VT_NAME, None)}
  }
  #[inline]
  pub fn metadata(&self) -> Option<SubtitleTrackMeta<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<SubtitleTrackMeta>>(AddSubtitleSource::VT_METADATA, None)}
  }
}

impl ::flatbuffers::Verifiable for AddSubtitleSource<'_> {
  #[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, true)?
     .visit_field::<bool>("select", Self::VT_SELECT, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<SubtitleTrackMeta>>("metadata", Self::VT_METADATA, false)?
     .finish();
    Ok(())
  }
}
pub struct AddSubtitleSourceArgs<'a> {
    pub url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub select: bool,
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub metadata: Option<::flatbuffers::WIPOffset<SubtitleTrackMeta<'a>>>,
}
impl<'a> Default for AddSubtitleSourceArgs<'a> {
  #[inline]
  fn default() -> Self {
    AddSubtitleSourceArgs {
      url: None, // required field
      select: false,
      name: None,
      metadata: None,
    }
  }
}

pub struct AddSubtitleSourceBuilder<'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> AddSubtitleSourceBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_url(&mut self, url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddSubtitleSource::VT_URL, url);
  }
  #[inline]
  pub fn add_select(&mut self, select: bool) {
    self.fbb_.push_slot::<bool>(AddSubtitleSource::VT_SELECT, select, false);
  }
  #[inline]
  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddSubtitleSource::VT_NAME, name);
  }
  #[inline]
  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<SubtitleTrackMeta<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<SubtitleTrackMeta>>(AddSubtitleSource::VT_METADATA, metadata);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AddSubtitleSourceBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AddSubtitleSourceBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AddSubtitleSource<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AddSubtitleSource::VT_URL,"url");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SetProgressUpdateInterval<'a> {
  pub const VT_INTERVAL: ::flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn interval(&self) -> Option<&'a Time> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Time>(SetProgressUpdateInterval::VT_INTERVAL, None)}
  }
}

impl ::flatbuffers::Verifiable for SetProgressUpdateInterval<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Time>("interval", Self::VT_INTERVAL, false)?
     .finish();
    Ok(())
  }
}
pub struct SetProgressUpdateIntervalArgs<'a> {
    pub interval: Option<&'a Time>,
}
impl<'a> Default for SetProgressUpdateIntervalArgs<'a> {
  #[inline]
  fn default() -> Self {
    SetProgressUpdateIntervalArgs {
      interval: None,
    }
  }
}

pub struct SetProgressUpdateIntervalBuilder<'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> SetProgressUpdateIntervalBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_interval(&mut self, interval: &Time) {
    self.fbb_.push_slot_always::<&Time>(SetProgressUpdateInterval::VT_INTERVAL, interval);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SetProgressUpdateIntervalBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SetProgressUpdateIntervalBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<SetProgressUpdateInterval<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> StartMirroringSession<'a> {
  pub const VT_SESSION_ID: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    StartMirroringSession { _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 StartMirroringSessionArgs
  ) -> ::flatbuffers::WIPOffset<StartMirroringSession<'bldr>> {
    let mut builder = StartMirroringSessionBuilder::new(_fbb);
    builder.add_session_id(args.session_id);
    builder.finish()
  }


  #[inline]
  pub fn session_id(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(StartMirroringSession::VT_SESSION_ID, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for StartMirroringSession<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u16>("session_id", Self::VT_SESSION_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct StartMirroringSessionArgs {
    pub session_id: u16,
}
impl<'a> Default for StartMirroringSessionArgs {
  #[inline]
  fn default() -> Self {
    StartMirroringSessionArgs {
      session_id: 0,
    }
  }
}

pub struct StartMirroringSessionBuilder<'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> StartMirroringSessionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_session_id(&mut self, session_id: u16) {
    self.fbb_.push_slot::<u16>(StartMirroringSession::VT_SESSION_ID, session_id, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> StartMirroringSessionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    StartMirroringSessionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<StartMirroringSession<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> MirroringSessionDescription<'a> {
  pub const VT_SESSION_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_SDP: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    MirroringSessionDescription { _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 MirroringSessionDescriptionArgs<'args>
  ) -> ::flatbuffers::WIPOffset<MirroringSessionDescription<'bldr>> {
    let mut builder = MirroringSessionDescriptionBuilder::new(_fbb);
    if let Some(x) = args.sdp { builder.add_sdp(x); }
    builder.add_session_id(args.session_id);
    builder.finish()
  }


  #[inline]
  pub fn session_id(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(MirroringSessionDescription::VT_SESSION_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn sdp(&self) -> &'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>>(MirroringSessionDescription::VT_SDP, None).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for MirroringSessionDescription<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u16>("session_id", Self::VT_SESSION_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("sdp", Self::VT_SDP, true)?
     .finish();
    Ok(())
  }
}
pub struct MirroringSessionDescriptionArgs<'a> {
    pub session_id: u16,
    pub sdp: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for MirroringSessionDescriptionArgs<'a> {
  #[inline]
  fn default() -> Self {
    MirroringSessionDescriptionArgs {
      session_id: 0,
      sdp: None, // required field
    }
  }
}

pub struct MirroringSessionDescriptionBuilder<'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> MirroringSessionDescriptionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_session_id(&mut self, session_id: u16) {
    self.fbb_.push_slot::<u16>(MirroringSessionDescription::VT_SESSION_ID, session_id, 0);
  }
  #[inline]
  pub fn add_sdp(&mut self, sdp: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(MirroringSessionDescription::VT_SDP, sdp);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MirroringSessionDescriptionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MirroringSessionDescriptionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<MirroringSessionDescription<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MirroringSessionDescription::VT_SDP,"sdp");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> VolumeChanged<'a> {
  pub const VT_VOLUME: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    VolumeChanged { _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 VolumeChangedArgs
  ) -> ::flatbuffers::WIPOffset<VolumeChanged<'bldr>> {
    let mut builder = VolumeChangedBuilder::new(_fbb);
    builder.add_volume(args.volume);
    builder.finish()
  }


  #[inline]
  pub fn volume(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(VolumeChanged::VT_VOLUME, Some(0.0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for VolumeChanged<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<f32>("volume", Self::VT_VOLUME, false)?
     .finish();
    Ok(())
  }
}
pub struct VolumeChangedArgs {
    pub volume: f32,
}
impl<'a> Default for VolumeChangedArgs {
  #[inline]
  fn default() -> Self {
    VolumeChangedArgs {
      volume: 0.0,
    }
  }
}

pub struct VolumeChangedBuilder<'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> VolumeChangedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_volume(&mut self, volume: f32) {
    self.fbb_.push_slot::<f32>(VolumeChanged::VT_VOLUME, volume, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> VolumeChangedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    VolumeChangedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<VolumeChanged<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> PlaybackStateChanged<'a> {
  pub const VT_STATE: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    PlaybackStateChanged { _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 PlaybackStateChangedArgs
  ) -> ::flatbuffers::WIPOffset<PlaybackStateChanged<'bldr>> {
    let mut builder = PlaybackStateChangedBuilder::new(_fbb);
    builder.add_state(args.state);
    builder.finish()
  }


  #[inline]
  pub fn state(&self) -> PlaybackState {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<PlaybackState>(PlaybackStateChanged::VT_STATE, Some(PlaybackState::Idle)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for PlaybackStateChanged<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<PlaybackState>("state", Self::VT_STATE, false)?
     .finish();
    Ok(())
  }
}
pub struct PlaybackStateChangedArgs {
    pub state: PlaybackState,
}
impl<'a> Default for PlaybackStateChangedArgs {
  #[inline]
  fn default() -> Self {
    PlaybackStateChangedArgs {
      state: PlaybackState::Idle,
    }
  }
}

pub struct PlaybackStateChangedBuilder<'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> PlaybackStateChangedBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_state(&mut self, state: PlaybackState) {
    self.fbb_.push_slot::<PlaybackState>(PlaybackStateChanged::VT_STATE, state, PlaybackState::Idle);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PlaybackStateChangedBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PlaybackStateChangedBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<PlaybackStateChanged<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Error<'a> {
  pub const VT_KIND: ::flatbuffers::VOffsetT = 4;
  pub const VT_PACKET_NUM: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Error { _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 ErrorArgs
  ) -> ::flatbuffers::WIPOffset<Error<'bldr>> {
    let mut builder = ErrorBuilder::new(_fbb);
    if let Some(x) = args.packet_num { builder.add_packet_num(x); }
    builder.add_kind(args.kind);
    builder.finish()
  }


  #[inline]
  pub fn kind(&self) -> ErrorKind {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ErrorKind>(Error::VT_KIND, Some(ErrorKind::InvalidOpcode)).unwrap()}
  }
  #[inline]
  pub fn packet_num(&self) -> Option<u32> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(Error::VT_PACKET_NUM, None)}
  }
}

impl ::flatbuffers::Verifiable for Error<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<ErrorKind>("kind", Self::VT_KIND, false)?
     .visit_field::<u32>("packet_num", Self::VT_PACKET_NUM, false)?
     .finish();
    Ok(())
  }
}
pub struct ErrorArgs {
    pub kind: ErrorKind,
    pub packet_num: Option<u32>,
}
impl<'a> Default for ErrorArgs {
  #[inline]
  fn default() -> Self {
    ErrorArgs {
      kind: ErrorKind::InvalidOpcode,
      packet_num: None,
    }
  }
}

pub struct ErrorBuilder<'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> ErrorBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_kind(&mut self, kind: ErrorKind) {
    self.fbb_.push_slot::<ErrorKind>(Error::VT_KIND, kind, ErrorKind::InvalidOpcode);
  }
  #[inline]
  pub fn add_packet_num(&mut self, packet_num: u32) {
    self.fbb_.push_slot_always::<u32>(Error::VT_PACKET_NUM, packet_num);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ErrorBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ErrorBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Error<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> StopPlayback<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    StopPlayback { _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 StopPlaybackArgs
  ) -> ::flatbuffers::WIPOffset<StopPlayback<'bldr>> {
    let mut builder = StopPlaybackBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for StopPlayback<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct StopPlaybackArgs {
}
impl<'a> Default for StopPlaybackArgs {
  #[inline]
  fn default() -> Self {
    StopPlaybackArgs {
    }
  }
}

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

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

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

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

impl<'a> CompanionHelloRequest<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CompanionHelloRequest { _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 CompanionHelloRequestArgs
  ) -> ::flatbuffers::WIPOffset<CompanionHelloRequest<'bldr>> {
    let mut builder = CompanionHelloRequestBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for CompanionHelloRequest<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct CompanionHelloRequestArgs {
}
impl<'a> Default for CompanionHelloRequestArgs {
  #[inline]
  fn default() -> Self {
    CompanionHelloRequestArgs {
    }
  }
}

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

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

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

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

impl<'a> CompanionHelloResponse<'a> {
  pub const VT_PROVIDER_ID: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CompanionHelloResponse { _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 CompanionHelloResponseArgs
  ) -> ::flatbuffers::WIPOffset<CompanionHelloResponse<'bldr>> {
    let mut builder = CompanionHelloResponseBuilder::new(_fbb);
    builder.add_provider_id(args.provider_id);
    builder.finish()
  }


  #[inline]
  pub fn provider_id(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(CompanionHelloResponse::VT_PROVIDER_ID, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for CompanionHelloResponse<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u16>("provider_id", Self::VT_PROVIDER_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct CompanionHelloResponseArgs {
    pub provider_id: u16,
}
impl<'a> Default for CompanionHelloResponseArgs {
  #[inline]
  fn default() -> Self {
    CompanionHelloResponseArgs {
      provider_id: 0,
    }
  }
}

pub struct CompanionHelloResponseBuilder<'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> CompanionHelloResponseBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_provider_id(&mut self, provider_id: u16) {
    self.fbb_.push_slot::<u16>(CompanionHelloResponse::VT_PROVIDER_ID, provider_id, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CompanionHelloResponseBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CompanionHelloResponseBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CompanionHelloResponse<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> CompanionResourceInfoRequest<'a> {
  pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_RESOURCE_ID: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CompanionResourceInfoRequest { _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 CompanionResourceInfoRequestArgs
  ) -> ::flatbuffers::WIPOffset<CompanionResourceInfoRequest<'bldr>> {
    let mut builder = CompanionResourceInfoRequestBuilder::new(_fbb);
    builder.add_resource_id(args.resource_id);
    builder.add_request_id(args.request_id);
    builder.finish()
  }


  #[inline]
  pub fn request_id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CompanionResourceInfoRequest::VT_REQUEST_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn resource_id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CompanionResourceInfoRequest::VT_RESOURCE_ID, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for CompanionResourceInfoRequest<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
     .visit_field::<u32>("resource_id", Self::VT_RESOURCE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct CompanionResourceInfoRequestArgs {
    pub request_id: u32,
    pub resource_id: u32,
}
impl<'a> Default for CompanionResourceInfoRequestArgs {
  #[inline]
  fn default() -> Self {
    CompanionResourceInfoRequestArgs {
      request_id: 0,
      resource_id: 0,
    }
  }
}

pub struct CompanionResourceInfoRequestBuilder<'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> CompanionResourceInfoRequestBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_request_id(&mut self, request_id: u32) {
    self.fbb_.push_slot::<u32>(CompanionResourceInfoRequest::VT_REQUEST_ID, request_id, 0);
  }
  #[inline]
  pub fn add_resource_id(&mut self, resource_id: u32) {
    self.fbb_.push_slot::<u32>(CompanionResourceInfoRequest::VT_RESOURCE_ID, resource_id, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CompanionResourceInfoRequestBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CompanionResourceInfoRequestBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CompanionResourceInfoRequest<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> UnknownResourceSize<'a> {

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    UnknownResourceSize { _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 UnknownResourceSizeArgs
  ) -> ::flatbuffers::WIPOffset<UnknownResourceSize<'bldr>> {
    let mut builder = UnknownResourceSizeBuilder::new(_fbb);
    builder.finish()
  }

}

impl ::flatbuffers::Verifiable for UnknownResourceSize<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .finish();
    Ok(())
  }
}
pub struct UnknownResourceSizeArgs {
}
impl<'a> Default for UnknownResourceSizeArgs {
  #[inline]
  fn default() -> Self {
    UnknownResourceSizeArgs {
    }
  }
}

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

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

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

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

impl<'a> KnownResourceSize<'a> {
  pub const VT_SIZE: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    KnownResourceSize { _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 KnownResourceSizeArgs
  ) -> ::flatbuffers::WIPOffset<KnownResourceSize<'bldr>> {
    let mut builder = KnownResourceSizeBuilder::new(_fbb);
    builder.add_size(args.size);
    builder.finish()
  }


  #[inline]
  pub fn size(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(KnownResourceSize::VT_SIZE, Some(0)).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for KnownResourceSize<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u64>("size", Self::VT_SIZE, false)?
     .finish();
    Ok(())
  }
}
pub struct KnownResourceSizeArgs {
    pub size: u64,
}
impl<'a> Default for KnownResourceSizeArgs {
  #[inline]
  fn default() -> Self {
    KnownResourceSizeArgs {
      size: 0,
    }
  }
}

pub struct KnownResourceSizeBuilder<'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> KnownResourceSizeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_size(&mut self, size: u64) {
    self.fbb_.push_slot::<u64>(KnownResourceSize::VT_SIZE, size, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> KnownResourceSizeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    KnownResourceSizeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<KnownResourceSize<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> CompanionResourceInfoResponse<'a> {
  pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_CONTENT_TYPE: ::flatbuffers::VOffsetT = 6;
  pub const VT_RESOURCE_SIZE_TYPE: ::flatbuffers::VOffsetT = 8;
  pub const VT_RESOURCE_SIZE: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CompanionResourceInfoResponse { _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 CompanionResourceInfoResponseArgs<'args>
  ) -> ::flatbuffers::WIPOffset<CompanionResourceInfoResponse<'bldr>> {
    let mut builder = CompanionResourceInfoResponseBuilder::new(_fbb);
    if let Some(x) = args.resource_size { builder.add_resource_size(x); }
    if let Some(x) = args.content_type { builder.add_content_type(x); }
    builder.add_request_id(args.request_id);
    builder.add_resource_size_type(args.resource_size_type);
    builder.finish()
  }


  #[inline]
  pub fn request_id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CompanionResourceInfoResponse::VT_REQUEST_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn content_type(&self) -> &'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>>(CompanionResourceInfoResponse::VT_CONTENT_TYPE, None).unwrap()}
  }
  #[inline]
  pub fn resource_size_type(&self) -> CompanionResourceSize {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<CompanionResourceSize>(CompanionResourceInfoResponse::VT_RESOURCE_SIZE_TYPE, Some(CompanionResourceSize::NONE)).unwrap()}
  }
  #[inline]
  pub fn resource_size(&self) -> Option<::flatbuffers::Table<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(CompanionResourceInfoResponse::VT_RESOURCE_SIZE, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn resource_size_as_unknown(&self) -> Option<UnknownResourceSize<'a>> {
    if self.resource_size_type() == CompanionResourceSize::Unknown {
      self.resource_size().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { UnknownResourceSize::init_from_table(t) }
     })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn resource_size_as_known(&self) -> Option<KnownResourceSize<'a>> {
    if self.resource_size_type() == CompanionResourceSize::Known {
      self.resource_size().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { KnownResourceSize::init_from_table(t) }
     })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for CompanionResourceInfoResponse<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("content_type", Self::VT_CONTENT_TYPE, true)?
     .visit_union::<CompanionResourceSize, _>("resource_size_type", Self::VT_RESOURCE_SIZE_TYPE, "resource_size", Self::VT_RESOURCE_SIZE, false, |key, v, pos| {
        match key {
          CompanionResourceSize::Unknown => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<UnknownResourceSize>>("CompanionResourceSize::Unknown", pos),
          CompanionResourceSize::Known => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<KnownResourceSize>>("CompanionResourceSize::Known", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct CompanionResourceInfoResponseArgs<'a> {
    pub request_id: u32,
    pub content_type: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub resource_size_type: CompanionResourceSize,
    pub resource_size: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for CompanionResourceInfoResponseArgs<'a> {
  #[inline]
  fn default() -> Self {
    CompanionResourceInfoResponseArgs {
      request_id: 0,
      content_type: None, // required field
      resource_size_type: CompanionResourceSize::NONE,
      resource_size: None,
    }
  }
}

pub struct CompanionResourceInfoResponseBuilder<'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> CompanionResourceInfoResponseBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_request_id(&mut self, request_id: u32) {
    self.fbb_.push_slot::<u32>(CompanionResourceInfoResponse::VT_REQUEST_ID, request_id, 0);
  }
  #[inline]
  pub fn add_content_type(&mut self, content_type: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(CompanionResourceInfoResponse::VT_CONTENT_TYPE, content_type);
  }
  #[inline]
  pub fn add_resource_size_type(&mut self, resource_size_type: CompanionResourceSize) {
    self.fbb_.push_slot::<CompanionResourceSize>(CompanionResourceInfoResponse::VT_RESOURCE_SIZE_TYPE, resource_size_type, CompanionResourceSize::NONE);
  }
  #[inline]
  pub fn add_resource_size(&mut self, resource_size: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(CompanionResourceInfoResponse::VT_RESOURCE_SIZE, resource_size);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CompanionResourceInfoResponseBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CompanionResourceInfoResponseBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CompanionResourceInfoResponse<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, CompanionResourceInfoResponse::VT_CONTENT_TYPE,"content_type");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for CompanionResourceInfoResponse<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("CompanionResourceInfoResponse");
      ds.field("request_id", &self.request_id());
      ds.field("content_type", &self.content_type());
      ds.field("resource_size_type", &self.resource_size_type());
      match self.resource_size_type() {
        CompanionResourceSize::Unknown => {
          if let Some(x) = self.resource_size_as_unknown() {
            ds.field("resource_size", &x)
          } else {
            ds.field("resource_size", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        CompanionResourceSize::Known => {
          if let Some(x) = self.resource_size_as_known() {
            ds.field("resource_size", &x)
          } else {
            ds.field("resource_size", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("resource_size", &x)
        },
      };
      ds.finish()
  }
}
pub enum CompanionResourceRequestOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> CompanionResourceRequest<'a> {
  pub const VT_REQUEST_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_RESOURCE_ID: ::flatbuffers::VOffsetT = 6;
  pub const VT_READ_HEAD: ::flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    CompanionResourceRequest { _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 CompanionResourceRequestArgs<'args>
  ) -> ::flatbuffers::WIPOffset<CompanionResourceRequest<'bldr>> {
    let mut builder = CompanionResourceRequestBuilder::new(_fbb);
    if let Some(x) = args.read_head { builder.add_read_head(x); }
    builder.add_resource_id(args.resource_id);
    builder.add_request_id(args.request_id);
    builder.finish()
  }


  #[inline]
  pub fn request_id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CompanionResourceRequest::VT_REQUEST_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn resource_id(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CompanionResourceRequest::VT_RESOURCE_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn read_head(&self) -> Option<&'a ResourceReadHead> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ResourceReadHead>(CompanionResourceRequest::VT_READ_HEAD, None)}
  }
}

impl ::flatbuffers::Verifiable for CompanionResourceRequest<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<u32>("request_id", Self::VT_REQUEST_ID, false)?
     .visit_field::<u32>("resource_id", Self::VT_RESOURCE_ID, false)?
     .visit_field::<ResourceReadHead>("read_head", Self::VT_READ_HEAD, false)?
     .finish();
    Ok(())
  }
}
pub struct CompanionResourceRequestArgs<'a> {
    pub request_id: u32,
    pub resource_id: u32,
    pub read_head: Option<&'a ResourceReadHead>,
}
impl<'a> Default for CompanionResourceRequestArgs<'a> {
  #[inline]
  fn default() -> Self {
    CompanionResourceRequestArgs {
      request_id: 0,
      resource_id: 0,
      read_head: None,
    }
  }
}

pub struct CompanionResourceRequestBuilder<'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> CompanionResourceRequestBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_request_id(&mut self, request_id: u32) {
    self.fbb_.push_slot::<u32>(CompanionResourceRequest::VT_REQUEST_ID, request_id, 0);
  }
  #[inline]
  pub fn add_resource_id(&mut self, resource_id: u32) {
    self.fbb_.push_slot::<u32>(CompanionResourceRequest::VT_RESOURCE_ID, resource_id, 0);
  }
  #[inline]
  pub fn add_read_head(&mut self, read_head: &ResourceReadHead) {
    self.fbb_.push_slot_always::<&ResourceReadHead>(CompanionResourceRequest::VT_READ_HEAD, read_head);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CompanionResourceRequestBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CompanionResourceRequestBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<CompanionResourceRequest<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for CompanionResourceRequest<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("CompanionResourceRequest");
      ds.field("request_id", &self.request_id());
      ds.field("resource_id", &self.resource_id());
      ds.field("read_head", &self.read_head());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `Packet`
/// 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_packet_unchecked`.
pub fn root_as_packet(buf: &[u8]) -> Result<Packet<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<Packet>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `Packet` 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_packet_unchecked`.
pub fn size_prefixed_root_as_packet(buf: &[u8]) -> Result<Packet<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<Packet>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `Packet` 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_packet_unchecked`.
pub fn root_as_packet_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Packet<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<Packet<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `Packet` 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_packet_unchecked`.
pub fn size_prefixed_root_as_packet_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Packet<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<Packet<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a Packet and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `Packet`.
pub unsafe fn root_as_packet_unchecked(buf: &[u8]) -> Packet<'_> {
  unsafe { ::flatbuffers::root_unchecked::<Packet>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Packet and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Packet`.
pub unsafe fn size_prefixed_root_as_packet_unchecked(buf: &[u8]) -> Packet<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Packet>(buf) }
}
#[inline]
pub fn finish_packet_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<Packet<'a>>) {
  fbb.finish(root, None);
}

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