voce_schema/generated/

_combined_generated.rs

// automatically generated by the FlatBuffers compiler, do not modify


// @generated

use core::mem;
use core::cmp::Ordering;

extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};

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

  use core::mem;
  use core::cmp::Ordering;

  extern crate flatbuffers;
  use self::flatbuffers::{EndianScalar, Follow};

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LENGTH_UNIT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LENGTH_UNIT: i8 = 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_LENGTH_UNIT: [LengthUnit; 13] = [
  LengthUnit::Px,
  LengthUnit::Rem,
  LengthUnit::Em,
  LengthUnit::Percent,
  LengthUnit::Vw,
  LengthUnit::Vh,
  LengthUnit::Dvh,
  LengthUnit::Svh,
  LengthUnit::Auto,
  LengthUnit::FitContent,
  LengthUnit::MinContent,
  LengthUnit::MaxContent,
  LengthUnit::Fr,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LengthUnit(pub i8);
#[allow(non_upper_case_globals)]
impl LengthUnit {
  pub const Px: Self = Self(0);
  pub const Rem: Self = Self(1);
  pub const Em: Self = Self(2);
  pub const Percent: Self = Self(3);
  pub const Vw: Self = Self(4);
  pub const Vh: Self = Self(5);
  pub const Dvh: Self = Self(6);
  pub const Svh: Self = Self(7);
  pub const Auto: Self = Self(8);
  pub const FitContent: Self = Self(9);
  pub const MinContent: Self = Self(10);
  pub const MaxContent: Self = Self(11);
  pub const Fr: Self = Self(12);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 12;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Px,
    Self::Rem,
    Self::Em,
    Self::Percent,
    Self::Vw,
    Self::Vh,
    Self::Dvh,
    Self::Svh,
    Self::Auto,
    Self::FitContent,
    Self::MinContent,
    Self::MaxContent,
    Self::Fr,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Px => Some("Px"),
      Self::Rem => Some("Rem"),
      Self::Em => Some("Em"),
      Self::Percent => Some("Percent"),
      Self::Vw => Some("Vw"),
      Self::Vh => Some("Vh"),
      Self::Dvh => Some("Dvh"),
      Self::Svh => Some("Svh"),
      Self::Auto => Some("Auto"),
      Self::FitContent => Some("FitContent"),
      Self::MinContent => Some("MinContent"),
      Self::MaxContent => Some("MaxContent"),
      Self::Fr => Some("Fr"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for LengthUnit {
  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 LengthUnit {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for LengthUnit {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_EASING_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_EASING_TYPE: i8 = 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_EASING_TYPE: [EasingType; 5] = [
  EasingType::Linear,
  EasingType::CubicBezier,
  EasingType::Spring,
  EasingType::Steps,
  EasingType::CustomLinear,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct EasingType(pub i8);
#[allow(non_upper_case_globals)]
impl EasingType {
  pub const Linear: Self = Self(0);
  pub const CubicBezier: Self = Self(1);
  pub const Spring: Self = Self(2);
  pub const Steps: Self = Self(3);
  pub const CustomLinear: Self = Self(4);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for EasingType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_ALIGNMENT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ALIGNMENT: i8 = 7;
#[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_ALIGNMENT: [Alignment; 8] = [
  Alignment::Start,
  Alignment::Center,
  Alignment::End,
  Alignment::Stretch,
  Alignment::SpaceBetween,
  Alignment::SpaceAround,
  Alignment::SpaceEvenly,
  Alignment::Baseline,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Alignment(pub i8);
#[allow(non_upper_case_globals)]
impl Alignment {
  pub const Start: Self = Self(0);
  pub const Center: Self = Self(1);
  pub const End: Self = Self(2);
  pub const Stretch: Self = Self(3);
  pub const SpaceBetween: Self = Self(4);
  pub const SpaceAround: Self = Self(5);
  pub const SpaceEvenly: Self = Self(6);
  pub const Baseline: Self = Self(7);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for Alignment {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LAYOUT_DIRECTION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LAYOUT_DIRECTION: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_LAYOUT_DIRECTION: [LayoutDirection; 4] = [
  LayoutDirection::Row,
  LayoutDirection::Column,
  LayoutDirection::RowReverse,
  LayoutDirection::ColumnReverse,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LayoutDirection(pub i8);
#[allow(non_upper_case_globals)]
impl LayoutDirection {
  pub const Row: Self = Self(0);
  pub const Column: Self = Self(1);
  pub const RowReverse: Self = Self(2);
  pub const ColumnReverse: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for LayoutDirection {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TEXT_DIRECTION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_TEXT_DIRECTION: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TEXT_DIRECTION: [TextDirection; 3] = [
  TextDirection::Ltr,
  TextDirection::Rtl,
  TextDirection::Auto,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for TextDirection {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_OVERFLOW: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_OVERFLOW: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_OVERFLOW: [Overflow; 4] = [
  Overflow::Visible,
  Overflow::Hidden,
  Overflow::Scroll,
  Overflow::Auto,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Overflow(pub i8);
#[allow(non_upper_case_globals)]
impl Overflow {
  pub const Visible: Self = Self(0);
  pub const Hidden: Self = Self(1);
  pub const Scroll: Self = Self(2);
  pub const Auto: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for Overflow {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_POSITION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_POSITION: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_POSITION: [Position; 4] = [
  Position::Relative,
  Position::Absolute,
  Position::Fixed,
  Position::Sticky,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Position(pub i8);
#[allow(non_upper_case_globals)]
impl Position {
  pub const Relative: Self = Self(0);
  pub const Absolute: Self = Self(1);
  pub const Fixed: Self = Self(2);
  pub const Sticky: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for Position {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_BORDER_STYLE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_BORDER_STYLE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_BORDER_STYLE: [BorderStyle; 4] = [
  BorderStyle::None,
  BorderStyle::Solid,
  BorderStyle::Dashed,
  BorderStyle::Dotted,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct BorderStyle(pub i8);
#[allow(non_upper_case_globals)]
impl BorderStyle {
  pub const None: Self = Self(0);
  pub const Solid: Self = Self(1);
  pub const Dashed: Self = Self(2);
  pub const Dotted: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for BorderStyle {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_GESTURE_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_GESTURE_TYPE: i8 = 7;
#[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_GESTURE_TYPE: [GestureType; 8] = [
  GestureType::Tap,
  GestureType::DoubleTap,
  GestureType::LongPress,
  GestureType::Drag,
  GestureType::Swipe,
  GestureType::Pinch,
  GestureType::Hover,
  GestureType::Focus,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct GestureType(pub i8);
#[allow(non_upper_case_globals)]
impl GestureType {
  pub const Tap: Self = Self(0);
  pub const DoubleTap: Self = Self(1);
  pub const LongPress: Self = Self(2);
  pub const Drag: Self = Self(3);
  pub const Swipe: Self = Self(4);
  pub const Pinch: Self = Self(5);
  pub const Hover: Self = Self(6);
  pub const Focus: Self = Self(7);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for GestureType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SCROLL_AXIS: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SCROLL_AXIS: i8 = 1;
#[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_SCROLL_AXIS: [ScrollAxis; 2] = [
  ScrollAxis::Vertical,
  ScrollAxis::Horizontal,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ScrollAxis(pub i8);
#[allow(non_upper_case_globals)]
impl ScrollAxis {
  pub const Vertical: Self = Self(0);
  pub const Horizontal: Self = Self(1);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ScrollAxis {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SCROLL_TRIGGER: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SCROLL_TRIGGER: i8 = 1;
#[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_SCROLL_TRIGGER: [ScrollTrigger; 2] = [
  ScrollTrigger::ViewProgress,
  ScrollTrigger::ScrollProgress,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ScrollTrigger(pub i8);
#[allow(non_upper_case_globals)]
impl ScrollTrigger {
  /// Animate as element enters/exits viewport.
  pub const ViewProgress: Self = Self(0);
  /// Animate based on scroll position within a container.
  pub const ScrollProgress: Self = Self(1);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ScrollTrigger {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_REDUCED_MOTION_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_REDUCED_MOTION_STRATEGY: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_REDUCED_MOTION_STRATEGY: [ReducedMotionStrategy; 4] = [
  ReducedMotionStrategy::Remove,
  ReducedMotionStrategy::Simplify,
  ReducedMotionStrategy::ReduceDuration,
  ReducedMotionStrategy::Functional,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ReducedMotionStrategy(pub i8);
#[allow(non_upper_case_globals)]
impl ReducedMotionStrategy {
  /// Remove the animation entirely — snap to final state.
  pub const Remove: Self = Self(0);
  /// Replace with a simpler animation (e.g., opacity fade instead of slide).
  pub const Simplify: Self = Self(1);
  /// Keep the animation but reduce duration to near-instant.
  pub const ReduceDuration: Self = Self(2);
  /// This animation is functional (loading spinner, progress bar) —
  /// simplify but don't remove.
  pub const Functional: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ReducedMotionStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CHANGE_FREQUENCY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CHANGE_FREQUENCY: i8 = 6;
#[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_CHANGE_FREQUENCY: [ChangeFrequency; 7] = [
  ChangeFrequency::Always,
  ChangeFrequency::Hourly,
  ChangeFrequency::Daily,
  ChangeFrequency::Weekly,
  ChangeFrequency::Monthly,
  ChangeFrequency::Yearly,
  ChangeFrequency::Never,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ChangeFrequency(pub i8);
#[allow(non_upper_case_globals)]
impl ChangeFrequency {
  pub const Always: Self = Self(0);
  pub const Hourly: Self = Self(1);
  pub const Daily: Self = Self(2);
  pub const Weekly: Self = Self(3);
  pub const Monthly: Self = Self(4);
  pub const Yearly: Self = Self(5);
  pub const Never: Self = Self(6);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ChangeFrequency {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_ROUTE_TRANSITION_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ROUTE_TRANSITION_TYPE: i8 = 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_ROUTE_TRANSITION_TYPE: [RouteTransitionType; 5] = [
  RouteTransitionType::None,
  RouteTransitionType::Crossfade,
  RouteTransitionType::Slide,
  RouteTransitionType::SharedElement,
  RouteTransitionType::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RouteTransitionType(pub i8);
#[allow(non_upper_case_globals)]
impl RouteTransitionType {
  pub const None: Self = Self(0);
  pub const Crossfade: Self = Self(1);
  pub const Slide: Self = Self(2);
  pub const SharedElement: Self = Self(3);
  pub const Custom: Self = Self(4);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for RouteTransitionType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SLIDE_DIRECTION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SLIDE_DIRECTION: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_SLIDE_DIRECTION: [SlideDirection; 4] = [
  SlideDirection::Left,
  SlideDirection::Right,
  SlideDirection::Up,
  SlideDirection::Down,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct SlideDirection(pub i8);
#[allow(non_upper_case_globals)]
impl SlideDirection {
  pub const Left: Self = Self(0);
  pub const Right: Self = Self(1);
  pub const Up: Self = Self(2);
  pub const Down: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for SlideDirection {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_DATA_SOURCE_PROVIDER: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_DATA_SOURCE_PROVIDER: i8 = 5;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_DATA_SOURCE_PROVIDER: [DataSourceProvider; 6] = [
  DataSourceProvider::Rest,
  DataSourceProvider::GraphQL,
  DataSourceProvider::Supabase,
  DataSourceProvider::Firebase,
  DataSourceProvider::Convex,
  DataSourceProvider::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct DataSourceProvider(pub i8);
#[allow(non_upper_case_globals)]
impl DataSourceProvider {
  pub const Rest: Self = Self(0);
  pub const GraphQL: Self = Self(1);
  pub const Supabase: Self = Self(2);
  pub const Firebase: Self = Self(3);
  pub const Convex: Self = Self(4);
  pub const Custom: Self = Self(5);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for DataSourceProvider {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_HTTP_METHOD: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_HTTP_METHOD: i8 = 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_HTTP_METHOD: [HttpMethod; 5] = [
  HttpMethod::GET,
  HttpMethod::POST,
  HttpMethod::PUT,
  HttpMethod::PATCH,
  HttpMethod::DELETE,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct HttpMethod(pub i8);
#[allow(non_upper_case_globals)]
impl HttpMethod {
  pub const GET: Self = Self(0);
  pub const POST: Self = Self(1);
  pub const PUT: Self = Self(2);
  pub const PATCH: Self = Self(3);
  pub const DELETE: Self = Self(4);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for HttpMethod {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CACHE_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CACHE_STRATEGY: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_CACHE_STRATEGY: [CacheStrategy; 4] = [
  CacheStrategy::None,
  CacheStrategy::StaleWhileRevalidate,
  CacheStrategy::CacheUntilInvalidated,
  CacheStrategy::Static,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct CacheStrategy(pub i8);
#[allow(non_upper_case_globals)]
impl CacheStrategy {
  /// No caching — fetch every time.
  pub const None: Self = Self(0);
  /// Cache for a duration, serve stale while revalidating.
  pub const StaleWhileRevalidate: Self = Self(1);
  /// Cache until explicitly invalidated.
  pub const CacheUntilInvalidated: Self = Self(2);
  /// Fetch once at build time, bake into output.
  pub const Static: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for CacheStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_EFFECT_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_EFFECT_TYPE: i8 = 6;
#[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_EFFECT_TYPE: [EffectType; 7] = [
  EffectType::Analytics,
  EffectType::ApiCall,
  EffectType::Storage,
  EffectType::Haptic,
  EffectType::Log,
  EffectType::Navigate,
  EffectType::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct EffectType(pub i8);
#[allow(non_upper_case_globals)]
impl EffectType {
  /// Send an analytics event.
  pub const Analytics: Self = Self(0);
  /// Call an API endpoint (mutation).
  pub const ApiCall: Self = Self(1);
  /// Write to local/session storage.
  pub const Storage: Self = Self(2);
  /// Trigger haptic feedback.
  pub const Haptic: Self = Self(3);
  /// Log to console (development only).
  pub const Log: Self = Self(4);
  /// Navigate to a route.
  pub const Navigate: Self = Self(5);
  /// Custom effect (escape hatch).
  pub const Custom: Self = Self(6);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for EffectType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LIVE_REGION_POLITENESS: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LIVE_REGION_POLITENESS: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_LIVE_REGION_POLITENESS: [LiveRegionPoliteness; 3] = [
  LiveRegionPoliteness::Polite,
  LiveRegionPoliteness::Assertive,
  LiveRegionPoliteness::Off,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LiveRegionPoliteness(pub i8);
#[allow(non_upper_case_globals)]
impl LiveRegionPoliteness {
  /// Wait for user to be idle before announcing.
  pub const Polite: Self = Self(0);
  /// Interrupt current speech to announce immediately.
  pub const Assertive: Self = Self(1);
  /// Do not announce (region is silent).
  pub const Off: Self = Self(2);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for LiveRegionPoliteness {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LIVE_REGION_RELEVANT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LIVE_REGION_RELEVANT: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_LIVE_REGION_RELEVANT: [LiveRegionRelevant; 4] = [
  LiveRegionRelevant::Additions,
  LiveRegionRelevant::Removals,
  LiveRegionRelevant::Text,
  LiveRegionRelevant::All,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LiveRegionRelevant(pub i8);
#[allow(non_upper_case_globals)]
impl LiveRegionRelevant {
  /// Announce added content.
  pub const Additions: Self = Self(0);
  /// Announce removed content.
  pub const Removals: Self = Self(1);
  /// Announce text changes.
  pub const Text: Self = Self(2);
  /// Announce everything.
  pub const All: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for LiveRegionRelevant {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_FOCUS_TRAP_ESCAPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FOCUS_TRAP_ESCAPE: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_FOCUS_TRAP_ESCAPE: [FocusTrapEscape; 3] = [
  FocusTrapEscape::CloseOnEscape,
  FocusTrapEscape::NoEscape,
  FocusTrapEscape::FireEvent,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct FocusTrapEscape(pub i8);
#[allow(non_upper_case_globals)]
impl FocusTrapEscape {
  /// Pressing Escape closes the trap (standard for modals).
  pub const CloseOnEscape: Self = Self(0);
  /// Escape does nothing (trap must be closed programmatically).
  pub const NoEscape: Self = Self(1);
  /// Pressing Escape fires a state machine event.
  pub const FireEvent: Self = Self(2);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for FocusTrapEscape {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_PERSONALIZATION_CONDITION_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_PERSONALIZATION_CONDITION_TYPE: i8 = 6;
#[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_PERSONALIZATION_CONDITION_TYPE: [PersonalizationConditionType; 7] = [
  PersonalizationConditionType::Locale,
  PersonalizationConditionType::DeviceType,
  PersonalizationConditionType::ColorScheme,
  PersonalizationConditionType::ReducedMotion,
  PersonalizationConditionType::HighContrast,
  PersonalizationConditionType::Viewport,
  PersonalizationConditionType::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct PersonalizationConditionType(pub i8);
#[allow(non_upper_case_globals)]
impl PersonalizationConditionType {
  pub const Locale: Self = Self(0);
  pub const DeviceType: Self = Self(1);
  pub const ColorScheme: Self = Self(2);
  pub const ReducedMotion: Self = Self(3);
  pub const HighContrast: Self = Self(4);
  pub const Viewport: Self = Self(5);
  pub const Custom: Self = Self(6);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for PersonalizationConditionType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_OPTIMISTIC_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_OPTIMISTIC_STRATEGY: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_OPTIMISTIC_STRATEGY: [OptimisticStrategy; 3] = [
  OptimisticStrategy::None,
  OptimisticStrategy::MirrorInput,
  OptimisticStrategy::CustomTransform,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for OptimisticStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_ROLLBACK_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ROLLBACK_STRATEGY: i8 = 1;
#[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_ROLLBACK_STRATEGY: [RollbackStrategy; 2] = [
  RollbackStrategy::Revert,
  RollbackStrategy::ShowErrorKeepData,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RollbackStrategy(pub i8);
#[allow(non_upper_case_globals)]
impl RollbackStrategy {
  pub const Revert: Self = Self(0);
  pub const ShowErrorKeepData: Self = Self(1);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for RollbackStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_ERROR_FALLBACK: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ERROR_FALLBACK: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_ERROR_FALLBACK: [ErrorFallback; 3] = [
  ErrorFallback::ShowToast,
  ErrorFallback::ShowInlineError,
  ErrorFallback::Redirect,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ErrorFallback {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SUBSCRIPTION_TRANSPORT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SUBSCRIPTION_TRANSPORT: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_SUBSCRIPTION_TRANSPORT: [SubscriptionTransport; 3] = [
  SubscriptionTransport::WebSocket,
  SubscriptionTransport::ServerSentEvents,
  SubscriptionTransport::Polling,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for SubscriptionTransport {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_UPDATE_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_UPDATE_STRATEGY: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_UPDATE_STRATEGY: [UpdateStrategy; 3] = [
  UpdateStrategy::Replace,
  UpdateStrategy::Merge,
  UpdateStrategy::Append,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for UpdateStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_AUTH_PROVIDER: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_AUTH_PROVIDER: i8 = 5;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_AUTH_PROVIDER: [AuthProvider; 6] = [
  AuthProvider::Auth0,
  AuthProvider::Clerk,
  AuthProvider::Supabase,
  AuthProvider::Firebase,
  AuthProvider::NextAuth,
  AuthProvider::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct AuthProvider(pub i8);
#[allow(non_upper_case_globals)]
impl AuthProvider {
  pub const Auth0: Self = Self(0);
  pub const Clerk: Self = Self(1);
  pub const Supabase: Self = Self(2);
  pub const Firebase: Self = Self(3);
  pub const NextAuth: Self = Self(4);
  pub const Custom: Self = Self(5);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for AuthProvider {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_SESSION_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_SESSION_STRATEGY: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_SESSION_STRATEGY: [SessionStrategy; 3] = [
  SessionStrategy::JwtCookie,
  SessionStrategy::JwtHeader,
  SessionStrategy::SessionCookie,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for SessionStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CONTENT_CACHE_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CONTENT_CACHE_STRATEGY: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_CONTENT_CACHE_STRATEGY: [ContentCacheStrategy; 3] = [
  ContentCacheStrategy::Static,
  ContentCacheStrategy::Isr,
  ContentCacheStrategy::Dynamic,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ContentCacheStrategy(pub i8);
#[allow(non_upper_case_globals)]
impl ContentCacheStrategy {
  /// Fetch at compile time, bake into output.
  pub const Static: Self = Self(0);
  /// Fetch at compile time, include revalidation mechanism.
  pub const Isr: Self = Self(1);
  /// Fetch at runtime via DataNode.
  pub const Dynamic: Self = Self(2);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ContentCacheStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CONTENT_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CONTENT_TYPE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_CONTENT_TYPE: [ContentType; 4] = [
  ContentType::Text,
  ContentType::RichText,
  ContentType::Media,
  ContentType::Structured,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ContentType(pub i8);
#[allow(non_upper_case_globals)]
impl ContentType {
  pub const Text: Self = Self(0);
  pub const RichText: Self = Self(1);
  pub const Media: Self = Self(2);
  pub const Structured: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ContentType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_RICH_TEXT_BLOCK_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_RICH_TEXT_BLOCK_TYPE: i8 = 11;
#[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_RICH_TEXT_BLOCK_TYPE: [RichTextBlockType; 12] = [
  RichTextBlockType::Paragraph,
  RichTextBlockType::Heading,
  RichTextBlockType::UnorderedList,
  RichTextBlockType::OrderedList,
  RichTextBlockType::ListItem,
  RichTextBlockType::Image,
  RichTextBlockType::CodeBlock,
  RichTextBlockType::Blockquote,
  RichTextBlockType::Divider,
  RichTextBlockType::Table,
  RichTextBlockType::TableRow,
  RichTextBlockType::TableCell,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RichTextBlockType(pub i8);
#[allow(non_upper_case_globals)]
impl RichTextBlockType {
  pub const Paragraph: Self = Self(0);
  pub const Heading: Self = Self(1);
  pub const UnorderedList: Self = Self(2);
  pub const OrderedList: Self = Self(3);
  pub const ListItem: Self = Self(4);
  pub const Image: Self = Self(5);
  pub const CodeBlock: Self = Self(6);
  pub const Blockquote: Self = Self(7);
  pub const Divider: Self = Self(8);
  pub const Table: Self = Self(9);
  pub const TableRow: Self = Self(10);
  pub const TableCell: Self = Self(11);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 11;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Paragraph,
    Self::Heading,
    Self::UnorderedList,
    Self::OrderedList,
    Self::ListItem,
    Self::Image,
    Self::CodeBlock,
    Self::Blockquote,
    Self::Divider,
    Self::Table,
    Self::TableRow,
    Self::TableCell,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Paragraph => Some("Paragraph"),
      Self::Heading => Some("Heading"),
      Self::UnorderedList => Some("UnorderedList"),
      Self::OrderedList => Some("OrderedList"),
      Self::ListItem => Some("ListItem"),
      Self::Image => Some("Image"),
      Self::CodeBlock => Some("CodeBlock"),
      Self::Blockquote => Some("Blockquote"),
      Self::Divider => Some("Divider"),
      Self::Table => Some("Table"),
      Self::TableRow => Some("TableRow"),
      Self::TableCell => Some("TableCell"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for RichTextBlockType {
  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 RichTextBlockType {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for RichTextBlockType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_RICH_TEXT_MARK: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_RICH_TEXT_MARK: i8 = 6;
#[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_RICH_TEXT_MARK: [RichTextMark; 7] = [
  RichTextMark::Bold,
  RichTextMark::Italic,
  RichTextMark::Underline,
  RichTextMark::Strikethrough,
  RichTextMark::Code,
  RichTextMark::Subscript,
  RichTextMark::Superscript,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RichTextMark(pub i8);
#[allow(non_upper_case_globals)]
impl RichTextMark {
  pub const Bold: Self = Self(0);
  pub const Italic: Self = Self(1);
  pub const Underline: Self = Self(2);
  pub const Strikethrough: Self = Self(3);
  pub const Code: Self = Self(4);
  pub const Subscript: Self = Self(5);
  pub const Superscript: Self = Self(6);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for RichTextMark {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MESSAGE_PARAM_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MESSAGE_PARAM_TYPE: i8 = 5;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_MESSAGE_PARAM_TYPE: [MessageParamType; 6] = [
  MessageParamType::StringParam,
  MessageParamType::NumberParam,
  MessageParamType::DateParam,
  MessageParamType::CurrencyParam,
  MessageParamType::PluralParam,
  MessageParamType::SelectParam,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct MessageParamType(pub i8);
#[allow(non_upper_case_globals)]
impl MessageParamType {
  pub const StringParam: Self = Self(0);
  pub const NumberParam: Self = Self(1);
  pub const DateParam: Self = Self(2);
  pub const CurrencyParam: Self = Self(3);
  pub const PluralParam: Self = Self(4);
  pub const SelectParam: Self = Self(5);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for MessageParamType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_NUMBER_STYLE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_NUMBER_STYLE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_NUMBER_STYLE: [NumberStyle; 4] = [
  NumberStyle::Decimal,
  NumberStyle::Currency,
  NumberStyle::Percent,
  NumberStyle::Unit,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct NumberStyle(pub i8);
#[allow(non_upper_case_globals)]
impl NumberStyle {
  pub const Decimal: Self = Self(0);
  pub const Currency: Self = Self(1);
  pub const Percent: Self = Self(2);
  pub const Unit: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for NumberStyle {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_DATE_STYLE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_DATE_STYLE: i8 = 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_DATE_STYLE: [DateStyle; 5] = [
  DateStyle::Short,
  DateStyle::Medium,
  DateStyle::Long,
  DateStyle::Full,
  DateStyle::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct DateStyle(pub i8);
#[allow(non_upper_case_globals)]
impl DateStyle {
  pub const Short: Self = Self(0);
  pub const Medium: Self = Self(1);
  pub const Long: Self = Self(2);
  pub const Full: Self = Self(3);
  pub const Custom: Self = Self(4);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for DateStyle {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_OGTYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_OGTYPE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_OGTYPE: [OGType; 4] = [
  OGType::Website,
  OGType::Article,
  OGType::Product,
  OGType::Profile,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct OGType(pub i8);
#[allow(non_upper_case_globals)]
impl OGType {
  pub const Website: Self = Self(0);
  pub const Article: Self = Self(1);
  pub const Product: Self = Self(2);
  pub const Profile: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for OGType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TWITTER_CARD_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_TWITTER_CARD_TYPE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TWITTER_CARD_TYPE: [TwitterCardType; 4] = [
  TwitterCardType::Summary,
  TwitterCardType::SummaryLargeImage,
  TwitterCardType::App,
  TwitterCardType::Player,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct TwitterCardType(pub i8);
#[allow(non_upper_case_globals)]
impl TwitterCardType {
  pub const Summary: Self = Self(0);
  pub const SummaryLargeImage: Self = Self(1);
  pub const App: Self = Self(2);
  pub const Player: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for TwitterCardType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_IMAGE_PREVIEW_SIZE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_IMAGE_PREVIEW_SIZE: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_IMAGE_PREVIEW_SIZE: [ImagePreviewSize; 3] = [
  ImagePreviewSize::None,
  ImagePreviewSize::Standard,
  ImagePreviewSize::Large,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ImagePreviewSize {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_FORM_FIELD_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FORM_FIELD_TYPE: i8 = 18;
#[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_FORM_FIELD_TYPE: [FormFieldType; 19] = [
  FormFieldType::Text,
  FormFieldType::Email,
  FormFieldType::Password,
  FormFieldType::Number,
  FormFieldType::Tel,
  FormFieldType::Url,
  FormFieldType::Search,
  FormFieldType::Select,
  FormFieldType::MultiSelect,
  FormFieldType::Checkbox,
  FormFieldType::Radio,
  FormFieldType::Textarea,
  FormFieldType::File,
  FormFieldType::Date,
  FormFieldType::Time,
  FormFieldType::DateTimeLocal,
  FormFieldType::Hidden,
  FormFieldType::Color,
  FormFieldType::Range,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct FormFieldType(pub i8);
#[allow(non_upper_case_globals)]
impl FormFieldType {
  pub const Text: Self = Self(0);
  pub const Email: Self = Self(1);
  pub const Password: Self = Self(2);
  pub const Number: Self = Self(3);
  pub const Tel: Self = Self(4);
  pub const Url: Self = Self(5);
  pub const Search: Self = Self(6);
  pub const Select: Self = Self(7);
  pub const MultiSelect: Self = Self(8);
  pub const Checkbox: Self = Self(9);
  pub const Radio: Self = Self(10);
  pub const Textarea: Self = Self(11);
  pub const File: Self = Self(12);
  pub const Date: Self = Self(13);
  pub const Time: Self = Self(14);
  pub const DateTimeLocal: Self = Self(15);
  pub const Hidden: Self = Self(16);
  pub const Color: Self = Self(17);
  pub const Range: Self = Self(18);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 18;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Text,
    Self::Email,
    Self::Password,
    Self::Number,
    Self::Tel,
    Self::Url,
    Self::Search,
    Self::Select,
    Self::MultiSelect,
    Self::Checkbox,
    Self::Radio,
    Self::Textarea,
    Self::File,
    Self::Date,
    Self::Time,
    Self::DateTimeLocal,
    Self::Hidden,
    Self::Color,
    Self::Range,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Text => Some("Text"),
      Self::Email => Some("Email"),
      Self::Password => Some("Password"),
      Self::Number => Some("Number"),
      Self::Tel => Some("Tel"),
      Self::Url => Some("Url"),
      Self::Search => Some("Search"),
      Self::Select => Some("Select"),
      Self::MultiSelect => Some("MultiSelect"),
      Self::Checkbox => Some("Checkbox"),
      Self::Radio => Some("Radio"),
      Self::Textarea => Some("Textarea"),
      Self::File => Some("File"),
      Self::Date => Some("Date"),
      Self::Time => Some("Time"),
      Self::DateTimeLocal => Some("DateTimeLocal"),
      Self::Hidden => Some("Hidden"),
      Self::Color => Some("Color"),
      Self::Range => Some("Range"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for FormFieldType {
  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 FormFieldType {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for FormFieldType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_VALIDATION_MODE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_VALIDATION_MODE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_VALIDATION_MODE: [ValidationMode; 4] = [
  ValidationMode::OnSubmit,
  ValidationMode::OnBlur,
  ValidationMode::OnChange,
  ValidationMode::OnBlurThenChange,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ValidationMode(pub i8);
#[allow(non_upper_case_globals)]
impl ValidationMode {
  /// Validate all fields on submit only.
  pub const OnSubmit: Self = Self(0);
  /// Validate each field on blur.
  pub const OnBlur: Self = Self(1);
  /// Validate on every keystroke (use sparingly).
  pub const OnChange: Self = Self(2);
  /// Validate on blur, then on change after first error (best UX).
  pub const OnBlurThenChange: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ValidationMode {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_FORM_ENCODING: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FORM_ENCODING: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_FORM_ENCODING: [FormEncoding; 3] = [
  FormEncoding::UrlEncoded,
  FormEncoding::Multipart,
  FormEncoding::Json,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for FormEncoding {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_AUTOCOMPLETE_HINT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_AUTOCOMPLETE_HINT: i8 = 17;
#[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_AUTOCOMPLETE_HINT: [AutocompleteHint; 18] = [
  AutocompleteHint::Off,
  AutocompleteHint::On,
  AutocompleteHint::Name,
  AutocompleteHint::GivenName,
  AutocompleteHint::FamilyName,
  AutocompleteHint::Email,
  AutocompleteHint::Username,
  AutocompleteHint::NewPassword,
  AutocompleteHint::CurrentPassword,
  AutocompleteHint::Tel,
  AutocompleteHint::StreetAddress,
  AutocompleteHint::City,
  AutocompleteHint::State,
  AutocompleteHint::PostalCode,
  AutocompleteHint::Country,
  AutocompleteHint::CreditCardNumber,
  AutocompleteHint::CreditCardExp,
  AutocompleteHint::CreditCardCsc,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct AutocompleteHint(pub i8);
#[allow(non_upper_case_globals)]
impl AutocompleteHint {
  pub const Off: Self = Self(0);
  pub const On: Self = Self(1);
  pub const Name: Self = Self(2);
  pub const GivenName: Self = Self(3);
  pub const FamilyName: Self = Self(4);
  pub const Email: Self = Self(5);
  pub const Username: Self = Self(6);
  pub const NewPassword: Self = Self(7);
  pub const CurrentPassword: Self = Self(8);
  pub const Tel: Self = Self(9);
  pub const StreetAddress: Self = Self(10);
  pub const City: Self = Self(11);
  pub const State: Self = Self(12);
  pub const PostalCode: Self = Self(13);
  pub const Country: Self = Self(14);
  pub const CreditCardNumber: Self = Self(15);
  pub const CreditCardExp: Self = Self(16);
  pub const CreditCardCsc: Self = Self(17);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 17;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Off,
    Self::On,
    Self::Name,
    Self::GivenName,
    Self::FamilyName,
    Self::Email,
    Self::Username,
    Self::NewPassword,
    Self::CurrentPassword,
    Self::Tel,
    Self::StreetAddress,
    Self::City,
    Self::State,
    Self::PostalCode,
    Self::Country,
    Self::CreditCardNumber,
    Self::CreditCardExp,
    Self::CreditCardCsc,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Off => Some("Off"),
      Self::On => Some("On"),
      Self::Name => Some("Name"),
      Self::GivenName => Some("GivenName"),
      Self::FamilyName => Some("FamilyName"),
      Self::Email => Some("Email"),
      Self::Username => Some("Username"),
      Self::NewPassword => Some("NewPassword"),
      Self::CurrentPassword => Some("CurrentPassword"),
      Self::Tel => Some("Tel"),
      Self::StreetAddress => Some("StreetAddress"),
      Self::City => Some("City"),
      Self::State => Some("State"),
      Self::PostalCode => Some("PostalCode"),
      Self::Country => Some("Country"),
      Self::CreditCardNumber => Some("CreditCardNumber"),
      Self::CreditCardExp => Some("CreditCardExp"),
      Self::CreditCardCsc => Some("CreditCardCsc"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for AutocompleteHint {
  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 AutocompleteHint {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for AutocompleteHint {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_VALIDATION_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_VALIDATION_TYPE: i8 = 8;
#[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_VALIDATION_TYPE: [ValidationType; 9] = [
  ValidationType::Required,
  ValidationType::MinLength,
  ValidationType::MaxLength,
  ValidationType::Pattern,
  ValidationType::Min,
  ValidationType::Max,
  ValidationType::Email,
  ValidationType::Url,
  ValidationType::Custom,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ValidationType(pub i8);
#[allow(non_upper_case_globals)]
impl ValidationType {
  pub const Required: Self = Self(0);
  pub const MinLength: Self = Self(1);
  pub const MaxLength: Self = Self(2);
  pub const Pattern: Self = Self(3);
  pub const Min: Self = Self(4);
  pub const Max: Self = Self(5);
  pub const Email: Self = Self(6);
  pub const Url: Self = Self(7);
  pub const Custom: Self = Self(8);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ValidationType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CONTAINER_LAYOUT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CONTAINER_LAYOUT: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_CONTAINER_LAYOUT: [ContainerLayout; 4] = [
  ContainerLayout::Stack,
  ContainerLayout::Flex,
  ContainerLayout::Grid,
  ContainerLayout::Absolute,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ContainerLayout(pub i8);
#[allow(non_upper_case_globals)]
impl ContainerLayout {
  pub const Stack: Self = Self(0);
  pub const Flex: Self = Self(1);
  pub const Grid: Self = Self(2);
  pub const Absolute: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ContainerLayout {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_FONT_WEIGHT: i16 = 100;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FONT_WEIGHT: i16 = 900;
#[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_FONT_WEIGHT: [FontWeight; 9] = [
  FontWeight::Thin,
  FontWeight::ExtraLight,
  FontWeight::Light,
  FontWeight::Regular,
  FontWeight::Medium,
  FontWeight::SemiBold,
  FontWeight::Bold,
  FontWeight::ExtraBold,
  FontWeight::Black,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct FontWeight(pub i16);
#[allow(non_upper_case_globals)]
impl FontWeight {
  pub const Thin: Self = Self(100);
  pub const ExtraLight: Self = Self(200);
  pub const Light: Self = Self(300);
  pub const Regular: Self = Self(400);
  pub const Medium: Self = Self(500);
  pub const SemiBold: Self = Self(600);
  pub const Bold: Self = Self(700);
  pub const ExtraBold: Self = Self(800);
  pub const Black: Self = Self(900);

  pub const ENUM_MIN: i16 = 100;
  pub const ENUM_MAX: i16 = 900;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::Thin,
    Self::ExtraLight,
    Self::Light,
    Self::Regular,
    Self::Medium,
    Self::SemiBold,
    Self::Bold,
    Self::ExtraBold,
    Self::Black,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::Thin => Some("Thin"),
      Self::ExtraLight => Some("ExtraLight"),
      Self::Light => Some("Light"),
      Self::Regular => Some("Regular"),
      Self::Medium => Some("Medium"),
      Self::SemiBold => Some("SemiBold"),
      Self::Bold => Some("Bold"),
      Self::ExtraBold => Some("ExtraBold"),
      Self::Black => Some("Black"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for FontWeight {
  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 FontWeight {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
    Self(b)
  }
}

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for FontWeight {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TEXT_ALIGN: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_TEXT_ALIGN: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TEXT_ALIGN: [TextAlign; 4] = [
  TextAlign::Start,
  TextAlign::Center,
  TextAlign::End,
  TextAlign::Justify,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct TextAlign(pub i8);
#[allow(non_upper_case_globals)]
impl TextAlign {
  pub const Start: Self = Self(0);
  pub const Center: Self = Self(1);
  pub const End: Self = Self(2);
  pub const Justify: Self = Self(3);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for TextAlign {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TEXT_OVERFLOW: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_TEXT_OVERFLOW: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TEXT_OVERFLOW: [TextOverflow; 3] = [
  TextOverflow::Clip,
  TextOverflow::Ellipsis,
  TextOverflow::Fade,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for TextOverflow {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TEXT_DECORATION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_TEXT_DECORATION: i8 = 2;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TEXT_DECORATION: [TextDecoration; 3] = [
  TextDecoration::None,
  TextDecoration::Underline,
  TextDecoration::LineThrough,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for TextDecoration {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_MEDIA_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_MEDIA_TYPE: i8 = 3;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_MEDIA_TYPE: [MediaType; 4] = [
  MediaType::Image,
  MediaType::Video,
  MediaType::Audio,
  MediaType::Svg,
];

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

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for MediaType {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LOADING_STRATEGY: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LOADING_STRATEGY: i8 = 1;
#[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_LOADING_STRATEGY: [LoadingStrategy; 2] = [
  LoadingStrategy::Eager,
  LoadingStrategy::Lazy,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LoadingStrategy(pub i8);
#[allow(non_upper_case_globals)]
impl LoadingStrategy {
  pub const Eager: Self = Self(0);
  pub const Lazy: Self = Self(1);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for LoadingStrategy {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_OBJECT_FIT: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_OBJECT_FIT: i8 = 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_OBJECT_FIT: [ObjectFit; 5] = [
  ObjectFit::Cover,
  ObjectFit::Contain,
  ObjectFit::Fill,
  ObjectFit::ScaleDown,
  ObjectFit::None,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ObjectFit(pub i8);
#[allow(non_upper_case_globals)]
impl ObjectFit {
  pub const Cover: Self = Self(0);
  pub const Contain: Self = Self(1);
  pub const Fill: Self = Self(2);
  pub const ScaleDown: Self = Self(3);
  pub const None: Self = Self(4);

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

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

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

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

impl flatbuffers::SimpleToVerifyInSlice for ObjectFit {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_CHILD_UNION: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_CHILD_UNION: u8 = 27;
#[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_CHILD_UNION: [ChildUnion; 28] = [
  ChildUnion::NONE,
  ChildUnion::Container,
  ChildUnion::Surface,
  ChildUnion::TextNode,
  ChildUnion::MediaNode,
  ChildUnion::StateMachine,
  ChildUnion::DataNode,
  ChildUnion::ComputeNode,
  ChildUnion::EffectNode,
  ChildUnion::ContextNode,
  ChildUnion::AnimationTransition,
  ChildUnion::Sequence,
  ChildUnion::GestureHandler,
  ChildUnion::ScrollBinding,
  ChildUnion::PhysicsBody,
  ChildUnion::RouteMap,
  ChildUnion::SemanticNode,
  ChildUnion::LiveRegion,
  ChildUnion::FocusTrap,
  ChildUnion::ThemeNode,
  ChildUnion::PersonalizationSlot,
  ChildUnion::ResponsiveRule,
  ChildUnion::ActionNode,
  ChildUnion::SubscriptionNode,
  ChildUnion::AuthContextNode,
  ChildUnion::ContentSlot,
  ChildUnion::RichTextNode,
  ChildUnion::FormNode,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ChildUnion(pub u8);
#[allow(non_upper_case_globals)]
impl ChildUnion {
  pub const NONE: Self = Self(0);
  pub const Container: Self = Self(1);
  pub const Surface: Self = Self(2);
  pub const TextNode: Self = Self(3);
  pub const MediaNode: Self = Self(4);
  pub const StateMachine: Self = Self(5);
  pub const DataNode: Self = Self(6);
  pub const ComputeNode: Self = Self(7);
  pub const EffectNode: Self = Self(8);
  pub const ContextNode: Self = Self(9);
  pub const AnimationTransition: Self = Self(10);
  pub const Sequence: Self = Self(11);
  pub const GestureHandler: Self = Self(12);
  pub const ScrollBinding: Self = Self(13);
  pub const PhysicsBody: Self = Self(14);
  pub const RouteMap: Self = Self(15);
  pub const SemanticNode: Self = Self(16);
  pub const LiveRegion: Self = Self(17);
  pub const FocusTrap: Self = Self(18);
  pub const ThemeNode: Self = Self(19);
  pub const PersonalizationSlot: Self = Self(20);
  pub const ResponsiveRule: Self = Self(21);
  pub const ActionNode: Self = Self(22);
  pub const SubscriptionNode: Self = Self(23);
  pub const AuthContextNode: Self = Self(24);
  pub const ContentSlot: Self = Self(25);
  pub const RichTextNode: Self = Self(26);
  pub const FormNode: Self = Self(27);

  pub const ENUM_MIN: u8 = 0;
  pub const ENUM_MAX: u8 = 27;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::NONE,
    Self::Container,
    Self::Surface,
    Self::TextNode,
    Self::MediaNode,
    Self::StateMachine,
    Self::DataNode,
    Self::ComputeNode,
    Self::EffectNode,
    Self::ContextNode,
    Self::AnimationTransition,
    Self::Sequence,
    Self::GestureHandler,
    Self::ScrollBinding,
    Self::PhysicsBody,
    Self::RouteMap,
    Self::SemanticNode,
    Self::LiveRegion,
    Self::FocusTrap,
    Self::ThemeNode,
    Self::PersonalizationSlot,
    Self::ResponsiveRule,
    Self::ActionNode,
    Self::SubscriptionNode,
    Self::AuthContextNode,
    Self::ContentSlot,
    Self::RichTextNode,
    Self::FormNode,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::NONE => Some("NONE"),
      Self::Container => Some("Container"),
      Self::Surface => Some("Surface"),
      Self::TextNode => Some("TextNode"),
      Self::MediaNode => Some("MediaNode"),
      Self::StateMachine => Some("StateMachine"),
      Self::DataNode => Some("DataNode"),
      Self::ComputeNode => Some("ComputeNode"),
      Self::EffectNode => Some("EffectNode"),
      Self::ContextNode => Some("ContextNode"),
      Self::AnimationTransition => Some("AnimationTransition"),
      Self::Sequence => Some("Sequence"),
      Self::GestureHandler => Some("GestureHandler"),
      Self::ScrollBinding => Some("ScrollBinding"),
      Self::PhysicsBody => Some("PhysicsBody"),
      Self::RouteMap => Some("RouteMap"),
      Self::SemanticNode => Some("SemanticNode"),
      Self::LiveRegion => Some("LiveRegion"),
      Self::FocusTrap => Some("FocusTrap"),
      Self::ThemeNode => Some("ThemeNode"),
      Self::PersonalizationSlot => Some("PersonalizationSlot"),
      Self::ResponsiveRule => Some("ResponsiveRule"),
      Self::ActionNode => Some("ActionNode"),
      Self::SubscriptionNode => Some("SubscriptionNode"),
      Self::AuthContextNode => Some("AuthContextNode"),
      Self::ContentSlot => Some("ContentSlot"),
      Self::RichTextNode => Some("RichTextNode"),
      Self::FormNode => Some("FormNode"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for ChildUnion {
  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 ChildUnion {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
    Self(b)
  }
}

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

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

impl flatbuffers::SimpleToVerifyInSlice for ChildUnion {}
pub struct ChildUnionUnionTableOffset {}

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

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

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

impl<'a> Color {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    r: u8,
    g: u8,
    b: u8,
    a: u8,
  ) -> Self {
    let mut s = Self([0; 4]);
    s.set_r(r);
    s.set_g(g);
    s.set_b(b);
    s.set_a(a);
    s
  }

  pub fn r(&self) -> u8 {
    let mut mem = core::mem::MaybeUninit::<<u8 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<u8 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_r(&mut self, x: u8) {
    let x_le = x.to_little_endian();
    // 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::<<u8 as EndianScalar>::Scalar>(),
      );
    }
  }

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

  pub fn set_g(&mut self, x: u8) {
    let x_le = x.to_little_endian();
    // 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[1..].as_mut_ptr(),
        core::mem::size_of::<<u8 as EndianScalar>::Scalar>(),
      );
    }
  }

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

  pub fn set_b(&mut self, x: u8) {
    let x_le = x.to_little_endian();
    // 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[2..].as_mut_ptr(),
        core::mem::size_of::<<u8 as EndianScalar>::Scalar>(),
      );
    }
  }

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

  pub fn set_a(&mut self, x: u8) {
    let x_le = x.to_little_endian();
    // 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[3..].as_mut_ptr(),
        core::mem::size_of::<<u8 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> Vec2 {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    x: f32,
    y: f32,
  ) -> Self {
    let mut s = Self([0; 8]);
    s.set_x(x);
    s.set_y(y);
    s
  }

  pub fn x(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_x(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn y(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_y(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> Vec3 {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    x: f32,
    y: f32,
    z: f32,
  ) -> Self {
    let mut s = Self([0; 12]);
    s.set_x(x);
    s.set_y(y);
    s.set_z(z);
    s
  }

  pub fn x(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_x(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn y(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_y(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn z(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_z(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> Vec4 {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    x: f32,
    y: f32,
    z: f32,
    w: f32,
  ) -> Self {
    let mut s = Self([0; 16]);
    s.set_x(x);
    s.set_y(y);
    s.set_z(z);
    s.set_w(w);
    s
  }

  pub fn x(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_x(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn y(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_y(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn z(&self) -> f32 {
    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    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::<<f32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_z(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

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

  pub fn set_w(&mut self, x: f32) {
    let x_le = x.to_little_endian();
    // 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[12..].as_mut_ptr(),
        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

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

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


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

impl flatbuffers::Verifiable for Length<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<f32>("value", Self::VT_VALUE, false)?
     .visit_field::<LengthUnit>("unit", Self::VT_UNIT, false)?
     .finish();
    Ok(())
  }
}
pub struct LengthArgs {
    pub value: f32,
    pub unit: LengthUnit,
}
impl<'a> Default for LengthArgs {
  #[inline]
  fn default() -> Self {
    LengthArgs {
      value: 0.0,
      unit: LengthUnit::Px,
    }
  }
}

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

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

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

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

impl<'a> Duration<'a> {
  pub const VT_MS: flatbuffers::VOffsetT = 4;

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


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

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

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

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

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

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

impl<'a> Angle<'a> {
  pub const VT_DEGREES: flatbuffers::VOffsetT = 4;

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


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

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

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

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

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

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

impl<'a> Easing<'a> {
  pub const VT_EASING_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_X1: flatbuffers::VOffsetT = 6;
  pub const VT_Y1: flatbuffers::VOffsetT = 8;
  pub const VT_X2: flatbuffers::VOffsetT = 10;
  pub const VT_Y2: flatbuffers::VOffsetT = 12;
  pub const VT_STIFFNESS: flatbuffers::VOffsetT = 14;
  pub const VT_DAMPING: flatbuffers::VOffsetT = 16;
  pub const VT_MASS: flatbuffers::VOffsetT = 18;
  pub const VT_STEPS: flatbuffers::VOffsetT = 20;
  pub const VT_POINTS: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Easing { _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 EasingArgs<'args>
  ) -> flatbuffers::WIPOffset<Easing<'bldr>> {
    let mut builder = EasingBuilder::new(_fbb);
    if let Some(x) = args.points { builder.add_points(x); }
    builder.add_steps(args.steps);
    builder.add_mass(args.mass);
    builder.add_damping(args.damping);
    builder.add_stiffness(args.stiffness);
    builder.add_y2(args.y2);
    builder.add_x2(args.x2);
    builder.add_y1(args.y1);
    builder.add_x1(args.x1);
    builder.add_easing_type(args.easing_type);
    builder.finish()
  }


  #[inline]
  pub fn easing_type(&self) -> EasingType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<EasingType>(Easing::VT_EASING_TYPE, Some(EasingType::Linear)).unwrap()}
  }
  #[inline]
  pub fn x1(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_X1, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn y1(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_Y1, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn x2(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_X2, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn y2(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_Y2, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn stiffness(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_STIFFNESS, Some(200.0)).unwrap()}
  }
  #[inline]
  pub fn damping(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_DAMPING, Some(20.0)).unwrap()}
  }
  #[inline]
  pub fn mass(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Easing::VT_MASS, Some(1.0)).unwrap()}
  }
  #[inline]
  pub fn steps(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(Easing::VT_STEPS, Some(0)).unwrap()}
  }
  #[inline]
  pub fn points(&self) -> Option<flatbuffers::Vector<'a, f32>> {
    // 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, f32>>>(Easing::VT_POINTS, None)}
  }
}

impl flatbuffers::Verifiable for Easing<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<EasingType>("easing_type", Self::VT_EASING_TYPE, false)?
     .visit_field::<f32>("x1", Self::VT_X1, false)?
     .visit_field::<f32>("y1", Self::VT_Y1, false)?
     .visit_field::<f32>("x2", Self::VT_X2, false)?
     .visit_field::<f32>("y2", Self::VT_Y2, false)?
     .visit_field::<f32>("stiffness", Self::VT_STIFFNESS, false)?
     .visit_field::<f32>("damping", Self::VT_DAMPING, false)?
     .visit_field::<f32>("mass", Self::VT_MASS, false)?
     .visit_field::<i32>("steps", Self::VT_STEPS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>("points", Self::VT_POINTS, false)?
     .finish();
    Ok(())
  }
}
pub struct EasingArgs<'a> {
    pub easing_type: EasingType,
    pub x1: f32,
    pub y1: f32,
    pub x2: f32,
    pub y2: f32,
    pub stiffness: f32,
    pub damping: f32,
    pub mass: f32,
    pub steps: i32,
    pub points: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
}
impl<'a> Default for EasingArgs<'a> {
  #[inline]
  fn default() -> Self {
    EasingArgs {
      easing_type: EasingType::Linear,
      x1: 0.0,
      y1: 0.0,
      x2: 0.0,
      y2: 0.0,
      stiffness: 200.0,
      damping: 20.0,
      mass: 1.0,
      steps: 0,
      points: None,
    }
  }
}

pub struct EasingBuilder<'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> EasingBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_easing_type(&mut self, easing_type: EasingType) {
    self.fbb_.push_slot::<EasingType>(Easing::VT_EASING_TYPE, easing_type, EasingType::Linear);
  }
  #[inline]
  pub fn add_x1(&mut self, x1: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_X1, x1, 0.0);
  }
  #[inline]
  pub fn add_y1(&mut self, y1: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_Y1, y1, 0.0);
  }
  #[inline]
  pub fn add_x2(&mut self, x2: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_X2, x2, 0.0);
  }
  #[inline]
  pub fn add_y2(&mut self, y2: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_Y2, y2, 0.0);
  }
  #[inline]
  pub fn add_stiffness(&mut self, stiffness: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_STIFFNESS, stiffness, 200.0);
  }
  #[inline]
  pub fn add_damping(&mut self, damping: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_DAMPING, damping, 20.0);
  }
  #[inline]
  pub fn add_mass(&mut self, mass: f32) {
    self.fbb_.push_slot::<f32>(Easing::VT_MASS, mass, 1.0);
  }
  #[inline]
  pub fn add_steps(&mut self, steps: i32) {
    self.fbb_.push_slot::<i32>(Easing::VT_STEPS, steps, 0);
  }
  #[inline]
  pub fn add_points(&mut self, points: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Easing::VT_POINTS, points);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> EasingBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    EasingBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Easing<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for Easing<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("Easing");
      ds.field("easing_type", &self.easing_type());
      ds.field("x1", &self.x1());
      ds.field("y1", &self.y1());
      ds.field("x2", &self.x2());
      ds.field("y2", &self.y2());
      ds.field("stiffness", &self.stiffness());
      ds.field("damping", &self.damping());
      ds.field("mass", &self.mass());
      ds.field("steps", &self.steps());
      ds.field("points", &self.points());
      ds.finish()
  }
}
pub enum EdgeInsetsOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> EdgeInsets<'a> {
  pub const VT_TOP: flatbuffers::VOffsetT = 4;
  pub const VT_RIGHT: flatbuffers::VOffsetT = 6;
  pub const VT_BOTTOM: flatbuffers::VOffsetT = 8;
  pub const VT_LEFT: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    EdgeInsets { _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 EdgeInsetsArgs<'args>
  ) -> flatbuffers::WIPOffset<EdgeInsets<'bldr>> {
    let mut builder = EdgeInsetsBuilder::new(_fbb);
    if let Some(x) = args.left { builder.add_left(x); }
    if let Some(x) = args.bottom { builder.add_bottom(x); }
    if let Some(x) = args.right { builder.add_right(x); }
    if let Some(x) = args.top { builder.add_top(x); }
    builder.finish()
  }


  #[inline]
  pub fn top(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(EdgeInsets::VT_TOP, None)}
  }
  #[inline]
  pub fn right(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(EdgeInsets::VT_RIGHT, None)}
  }
  #[inline]
  pub fn bottom(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(EdgeInsets::VT_BOTTOM, None)}
  }
  #[inline]
  pub fn left(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(EdgeInsets::VT_LEFT, None)}
  }
}

impl flatbuffers::Verifiable for EdgeInsets<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("top", Self::VT_TOP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("right", Self::VT_RIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("bottom", Self::VT_BOTTOM, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("left", Self::VT_LEFT, false)?
     .finish();
    Ok(())
  }
}
pub struct EdgeInsetsArgs<'a> {
    pub top: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub right: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub bottom: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub left: Option<flatbuffers::WIPOffset<Length<'a>>>,
}
impl<'a> Default for EdgeInsetsArgs<'a> {
  #[inline]
  fn default() -> Self {
    EdgeInsetsArgs {
      top: None,
      right: None,
      bottom: None,
      left: None,
    }
  }
}

pub struct EdgeInsetsBuilder<'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> EdgeInsetsBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_top(&mut self, top: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(EdgeInsets::VT_TOP, top);
  }
  #[inline]
  pub fn add_right(&mut self, right: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(EdgeInsets::VT_RIGHT, right);
  }
  #[inline]
  pub fn add_bottom(&mut self, bottom: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(EdgeInsets::VT_BOTTOM, bottom);
  }
  #[inline]
  pub fn add_left(&mut self, left: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(EdgeInsets::VT_LEFT, left);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> EdgeInsetsBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    EdgeInsetsBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<EdgeInsets<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> CornerRadii<'a> {
  pub const VT_TOP_LEFT: flatbuffers::VOffsetT = 4;
  pub const VT_TOP_RIGHT: flatbuffers::VOffsetT = 6;
  pub const VT_BOTTOM_RIGHT: flatbuffers::VOffsetT = 8;
  pub const VT_BOTTOM_LEFT: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    CornerRadii { _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 CornerRadiiArgs<'args>
  ) -> flatbuffers::WIPOffset<CornerRadii<'bldr>> {
    let mut builder = CornerRadiiBuilder::new(_fbb);
    if let Some(x) = args.bottom_left { builder.add_bottom_left(x); }
    if let Some(x) = args.bottom_right { builder.add_bottom_right(x); }
    if let Some(x) = args.top_right { builder.add_top_right(x); }
    if let Some(x) = args.top_left { builder.add_top_left(x); }
    builder.finish()
  }


  #[inline]
  pub fn top_left(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(CornerRadii::VT_TOP_LEFT, None)}
  }
  #[inline]
  pub fn top_right(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(CornerRadii::VT_TOP_RIGHT, None)}
  }
  #[inline]
  pub fn bottom_right(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(CornerRadii::VT_BOTTOM_RIGHT, None)}
  }
  #[inline]
  pub fn bottom_left(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(CornerRadii::VT_BOTTOM_LEFT, None)}
  }
}

impl flatbuffers::Verifiable for CornerRadii<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("top_left", Self::VT_TOP_LEFT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("top_right", Self::VT_TOP_RIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("bottom_right", Self::VT_BOTTOM_RIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("bottom_left", Self::VT_BOTTOM_LEFT, false)?
     .finish();
    Ok(())
  }
}
pub struct CornerRadiiArgs<'a> {
    pub top_left: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub top_right: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub bottom_right: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub bottom_left: Option<flatbuffers::WIPOffset<Length<'a>>>,
}
impl<'a> Default for CornerRadiiArgs<'a> {
  #[inline]
  fn default() -> Self {
    CornerRadiiArgs {
      top_left: None,
      top_right: None,
      bottom_right: None,
      bottom_left: None,
    }
  }
}

pub struct CornerRadiiBuilder<'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> CornerRadiiBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_top_left(&mut self, top_left: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(CornerRadii::VT_TOP_LEFT, top_left);
  }
  #[inline]
  pub fn add_top_right(&mut self, top_right: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(CornerRadii::VT_TOP_RIGHT, top_right);
  }
  #[inline]
  pub fn add_bottom_right(&mut self, bottom_right: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(CornerRadii::VT_BOTTOM_RIGHT, bottom_right);
  }
  #[inline]
  pub fn add_bottom_left(&mut self, bottom_left: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(CornerRadii::VT_BOTTOM_LEFT, bottom_left);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> CornerRadiiBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CornerRadiiBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<CornerRadii<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Shadow<'a> {
  pub const VT_OFFSET_X: flatbuffers::VOffsetT = 4;
  pub const VT_OFFSET_Y: flatbuffers::VOffsetT = 6;
  pub const VT_BLUR: flatbuffers::VOffsetT = 8;
  pub const VT_SPREAD: flatbuffers::VOffsetT = 10;
  pub const VT_COLOR: flatbuffers::VOffsetT = 12;
  pub const VT_INSET: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Shadow { _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 ShadowArgs<'args>
  ) -> flatbuffers::WIPOffset<Shadow<'bldr>> {
    let mut builder = ShadowBuilder::new(_fbb);
    if let Some(x) = args.color { builder.add_color(x); }
    if let Some(x) = args.spread { builder.add_spread(x); }
    if let Some(x) = args.blur { builder.add_blur(x); }
    if let Some(x) = args.offset_y { builder.add_offset_y(x); }
    if let Some(x) = args.offset_x { builder.add_offset_x(x); }
    builder.add_inset(args.inset);
    builder.finish()
  }


  #[inline]
  pub fn offset_x(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Shadow::VT_OFFSET_X, None)}
  }
  #[inline]
  pub fn offset_y(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Shadow::VT_OFFSET_Y, None)}
  }
  #[inline]
  pub fn blur(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Shadow::VT_BLUR, None)}
  }
  #[inline]
  pub fn spread(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Shadow::VT_SPREAD, None)}
  }
  #[inline]
  pub fn color(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(Shadow::VT_COLOR, None)}
  }
  #[inline]
  pub fn inset(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Shadow::VT_INSET, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for Shadow<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("offset_x", Self::VT_OFFSET_X, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("offset_y", Self::VT_OFFSET_Y, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("blur", Self::VT_BLUR, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("spread", Self::VT_SPREAD, false)?
     .visit_field::<Color>("color", Self::VT_COLOR, false)?
     .visit_field::<bool>("inset", Self::VT_INSET, false)?
     .finish();
    Ok(())
  }
}
pub struct ShadowArgs<'a> {
    pub offset_x: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub offset_y: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub blur: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub spread: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub color: Option<&'a Color>,
    pub inset: bool,
}
impl<'a> Default for ShadowArgs<'a> {
  #[inline]
  fn default() -> Self {
    ShadowArgs {
      offset_x: None,
      offset_y: None,
      blur: None,
      spread: None,
      color: None,
      inset: false,
    }
  }
}

pub struct ShadowBuilder<'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> ShadowBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_offset_x(&mut self, offset_x: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Shadow::VT_OFFSET_X, offset_x);
  }
  #[inline]
  pub fn add_offset_y(&mut self, offset_y: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Shadow::VT_OFFSET_Y, offset_y);
  }
  #[inline]
  pub fn add_blur(&mut self, blur: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Shadow::VT_BLUR, blur);
  }
  #[inline]
  pub fn add_spread(&mut self, spread: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Shadow::VT_SPREAD, spread);
  }
  #[inline]
  pub fn add_color(&mut self, color: &Color) {
    self.fbb_.push_slot_always::<&Color>(Shadow::VT_COLOR, color);
  }
  #[inline]
  pub fn add_inset(&mut self, inset: bool) {
    self.fbb_.push_slot::<bool>(Shadow::VT_INSET, inset, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ShadowBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ShadowBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Shadow<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for Shadow<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("Shadow");
      ds.field("offset_x", &self.offset_x());
      ds.field("offset_y", &self.offset_y());
      ds.field("blur", &self.blur());
      ds.field("spread", &self.spread());
      ds.field("color", &self.color());
      ds.field("inset", &self.inset());
      ds.finish()
  }
}
pub enum DataBindingOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> DataBinding<'a> {
  pub const VT_SOURCE_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_FIELD_PATH: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    DataBinding { _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 DataBindingArgs<'args>
  ) -> flatbuffers::WIPOffset<DataBinding<'bldr>> {
    let mut builder = DataBindingBuilder::new(_fbb);
    if let Some(x) = args.field_path { builder.add_field_path(x); }
    if let Some(x) = args.source_node_id { builder.add_source_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn source_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(DataBinding::VT_SOURCE_NODE_ID, None)}
  }
  #[inline]
  pub fn field_path(&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>>(DataBinding::VT_FIELD_PATH, None)}
  }
}

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

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

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

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

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

impl<'a> Border<'a> {
  pub const VT_WIDTH: flatbuffers::VOffsetT = 4;
  pub const VT_STYLE: flatbuffers::VOffsetT = 6;
  pub const VT_COLOR: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Border { _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 BorderArgs<'args>
  ) -> flatbuffers::WIPOffset<Border<'bldr>> {
    let mut builder = BorderBuilder::new(_fbb);
    if let Some(x) = args.color { builder.add_color(x); }
    if let Some(x) = args.width { builder.add_width(x); }
    builder.add_style(args.style);
    builder.finish()
  }


  #[inline]
  pub fn width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Border::VT_WIDTH, None)}
  }
  #[inline]
  pub fn style(&self) -> BorderStyle {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<BorderStyle>(Border::VT_STYLE, Some(BorderStyle::Solid)).unwrap()}
  }
  #[inline]
  pub fn color(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(Border::VT_COLOR, None)}
  }
}

impl flatbuffers::Verifiable for Border<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("width", Self::VT_WIDTH, false)?
     .visit_field::<BorderStyle>("style", Self::VT_STYLE, false)?
     .visit_field::<Color>("color", Self::VT_COLOR, false)?
     .finish();
    Ok(())
  }
}
pub struct BorderArgs<'a> {
    pub width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub style: BorderStyle,
    pub color: Option<&'a Color>,
}
impl<'a> Default for BorderArgs<'a> {
  #[inline]
  fn default() -> Self {
    BorderArgs {
      width: None,
      style: BorderStyle::Solid,
      color: None,
    }
  }
}

pub struct BorderBuilder<'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> BorderBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_width(&mut self, width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Border::VT_WIDTH, width);
  }
  #[inline]
  pub fn add_style(&mut self, style: BorderStyle) {
    self.fbb_.push_slot::<BorderStyle>(Border::VT_STYLE, style, BorderStyle::Solid);
  }
  #[inline]
  pub fn add_color(&mut self, color: &Color) {
    self.fbb_.push_slot_always::<&Color>(Border::VT_COLOR, color);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> BorderBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    BorderBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Border<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> BorderSides<'a> {
  pub const VT_TOP: flatbuffers::VOffsetT = 4;
  pub const VT_RIGHT: flatbuffers::VOffsetT = 6;
  pub const VT_BOTTOM: flatbuffers::VOffsetT = 8;
  pub const VT_LEFT: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    BorderSides { _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 BorderSidesArgs<'args>
  ) -> flatbuffers::WIPOffset<BorderSides<'bldr>> {
    let mut builder = BorderSidesBuilder::new(_fbb);
    if let Some(x) = args.left { builder.add_left(x); }
    if let Some(x) = args.bottom { builder.add_bottom(x); }
    if let Some(x) = args.right { builder.add_right(x); }
    if let Some(x) = args.top { builder.add_top(x); }
    builder.finish()
  }


  #[inline]
  pub fn top(&self) -> Option<Border<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Border>>(BorderSides::VT_TOP, None)}
  }
  #[inline]
  pub fn right(&self) -> Option<Border<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Border>>(BorderSides::VT_RIGHT, None)}
  }
  #[inline]
  pub fn bottom(&self) -> Option<Border<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Border>>(BorderSides::VT_BOTTOM, None)}
  }
  #[inline]
  pub fn left(&self) -> Option<Border<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Border>>(BorderSides::VT_LEFT, None)}
  }
}

impl flatbuffers::Verifiable for BorderSides<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Border>>("top", Self::VT_TOP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Border>>("right", Self::VT_RIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Border>>("bottom", Self::VT_BOTTOM, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Border>>("left", Self::VT_LEFT, false)?
     .finish();
    Ok(())
  }
}
pub struct BorderSidesArgs<'a> {
    pub top: Option<flatbuffers::WIPOffset<Border<'a>>>,
    pub right: Option<flatbuffers::WIPOffset<Border<'a>>>,
    pub bottom: Option<flatbuffers::WIPOffset<Border<'a>>>,
    pub left: Option<flatbuffers::WIPOffset<Border<'a>>>,
}
impl<'a> Default for BorderSidesArgs<'a> {
  #[inline]
  fn default() -> Self {
    BorderSidesArgs {
      top: None,
      right: None,
      bottom: None,
      left: None,
    }
  }
}

pub struct BorderSidesBuilder<'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> BorderSidesBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_top(&mut self, top: flatbuffers::WIPOffset<Border<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Border>>(BorderSides::VT_TOP, top);
  }
  #[inline]
  pub fn add_right(&mut self, right: flatbuffers::WIPOffset<Border<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Border>>(BorderSides::VT_RIGHT, right);
  }
  #[inline]
  pub fn add_bottom(&mut self, bottom: flatbuffers::WIPOffset<Border<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Border>>(BorderSides::VT_BOTTOM, bottom);
  }
  #[inline]
  pub fn add_left(&mut self, left: flatbuffers::WIPOffset<Border<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Border>>(BorderSides::VT_LEFT, left);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> BorderSidesBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    BorderSidesBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<BorderSides<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AnimatedProperty<'a> {
  pub const VT_PROPERTY: flatbuffers::VOffsetT = 4;
  pub const VT_FROM: flatbuffers::VOffsetT = 6;
  pub const VT_TO: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AnimatedProperty { _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 AnimatedPropertyArgs<'args>
  ) -> flatbuffers::WIPOffset<AnimatedProperty<'bldr>> {
    let mut builder = AnimatedPropertyBuilder::new(_fbb);
    if let Some(x) = args.to { builder.add_to(x); }
    if let Some(x) = args.from { builder.add_from(x); }
    if let Some(x) = args.property { builder.add_property(x); }
    builder.finish()
  }


  /// CSS-like property path (e.g., "transform.translateY", "opacity", "background.color").
  #[inline]
  pub fn property(&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>>(AnimatedProperty::VT_PROPERTY, None).unwrap()}
  }
  /// Value in the "from" state.
  #[inline]
  pub fn from(&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>>(AnimatedProperty::VT_FROM, None).unwrap()}
  }
  /// Value in the "to" state.
  #[inline]
  pub fn to(&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>>(AnimatedProperty::VT_TO, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for AnimatedProperty<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("property", Self::VT_PROPERTY, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("from", Self::VT_FROM, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("to", Self::VT_TO, true)?
     .finish();
    Ok(())
  }
}
pub struct AnimatedPropertyArgs<'a> {
    pub property: Option<flatbuffers::WIPOffset<&'a str>>,
    pub from: Option<flatbuffers::WIPOffset<&'a str>>,
    pub to: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AnimatedPropertyArgs<'a> {
  #[inline]
  fn default() -> Self {
    AnimatedPropertyArgs {
      property: None, // required field
      from: None, // required field
      to: None, // required field
    }
  }
}

pub struct AnimatedPropertyBuilder<'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> AnimatedPropertyBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_property(&mut self, property: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimatedProperty::VT_PROPERTY, property);
  }
  #[inline]
  pub fn add_from(&mut self, from: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimatedProperty::VT_FROM, from);
  }
  #[inline]
  pub fn add_to(&mut self, to: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimatedProperty::VT_TO, to);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AnimatedPropertyBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AnimatedPropertyBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AnimatedProperty<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AnimatedProperty::VT_PROPERTY,"property");
    self.fbb_.required(o, AnimatedProperty::VT_FROM,"from");
    self.fbb_.required(o, AnimatedProperty::VT_TO,"to");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AnimationTransition<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 8;
  pub const VT_TRIGGER_STATE_MACHINE: flatbuffers::VOffsetT = 10;
  pub const VT_TRIGGER_EVENT: flatbuffers::VOffsetT = 12;
  pub const VT_PROPERTIES: flatbuffers::VOffsetT = 14;
  pub const VT_DURATION: flatbuffers::VOffsetT = 16;
  pub const VT_DELAY: flatbuffers::VOffsetT = 18;
  pub const VT_EASING: flatbuffers::VOffsetT = 20;
  pub const VT_REDUCED_MOTION: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AnimationTransition { _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 AnimationTransitionArgs<'args>
  ) -> flatbuffers::WIPOffset<AnimationTransition<'bldr>> {
    let mut builder = AnimationTransitionBuilder::new(_fbb);
    if let Some(x) = args.reduced_motion { builder.add_reduced_motion(x); }
    if let Some(x) = args.easing { builder.add_easing(x); }
    if let Some(x) = args.delay { builder.add_delay(x); }
    if let Some(x) = args.duration { builder.add_duration(x); }
    if let Some(x) = args.properties { builder.add_properties(x); }
    if let Some(x) = args.trigger_event { builder.add_trigger_event(x); }
    if let Some(x) = args.trigger_state_machine { builder.add_trigger_state_machine(x); }
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(AnimationTransition::VT_NODE_ID, None).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>>(AnimationTransition::VT_NAME, None)}
  }
  /// Target node to animate.
  #[inline]
  pub fn target_node_id(&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>>(AnimationTransition::VT_TARGET_NODE_ID, None).unwrap()}
  }
  /// Which state machine transition triggers this animation.
  #[inline]
  pub fn trigger_state_machine(&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>>(AnimationTransition::VT_TRIGGER_STATE_MACHINE, None)}
  }
  #[inline]
  pub fn trigger_event(&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>>(AnimationTransition::VT_TRIGGER_EVENT, None)}
  }
  /// Properties to animate.
  #[inline]
  pub fn properties(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'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<AnimatedProperty>>>>(AnimationTransition::VT_PROPERTIES, None).unwrap()}
  }
  /// Timing.
  #[inline]
  pub fn duration(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(AnimationTransition::VT_DURATION, None)}
  }
  #[inline]
  pub fn delay(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(AnimationTransition::VT_DELAY, None)}
  }
  #[inline]
  pub fn easing(&self) -> Option<Easing<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Easing>>(AnimationTransition::VT_EASING, None)}
  }
  /// Reduced motion alternative (required by validator).
  #[inline]
  pub fn reduced_motion(&self) -> Option<ReducedMotion<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ReducedMotion>>(AnimationTransition::VT_REDUCED_MOTION, None)}
  }
}

impl flatbuffers::Verifiable for AnimationTransition<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("trigger_state_machine", Self::VT_TRIGGER_STATE_MACHINE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("trigger_event", Self::VT_TRIGGER_EVENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AnimatedProperty>>>>("properties", Self::VT_PROPERTIES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("duration", Self::VT_DURATION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("delay", Self::VT_DELAY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Easing>>("easing", Self::VT_EASING, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ReducedMotion>>("reduced_motion", Self::VT_REDUCED_MOTION, false)?
     .finish();
    Ok(())
  }
}
pub struct AnimationTransitionArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub trigger_state_machine: Option<flatbuffers::WIPOffset<&'a str>>,
    pub trigger_event: Option<flatbuffers::WIPOffset<&'a str>>,
    pub properties: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'a>>>>>,
    pub duration: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub delay: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub easing: Option<flatbuffers::WIPOffset<Easing<'a>>>,
    pub reduced_motion: Option<flatbuffers::WIPOffset<ReducedMotion<'a>>>,
}
impl<'a> Default for AnimationTransitionArgs<'a> {
  #[inline]
  fn default() -> Self {
    AnimationTransitionArgs {
      node_id: None, // required field
      name: None,
      target_node_id: None, // required field
      trigger_state_machine: None,
      trigger_event: None,
      properties: None, // required field
      duration: None,
      delay: None,
      easing: None,
      reduced_motion: None,
    }
  }
}

pub struct AnimationTransitionBuilder<'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> AnimationTransitionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_NAME, name);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn add_trigger_state_machine(&mut self, trigger_state_machine: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_TRIGGER_STATE_MACHINE, trigger_state_machine);
  }
  #[inline]
  pub fn add_trigger_event(&mut self, trigger_event: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_TRIGGER_EVENT, trigger_event);
  }
  #[inline]
  pub fn add_properties(&mut self, properties: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AnimatedProperty<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AnimationTransition::VT_PROPERTIES, properties);
  }
  #[inline]
  pub fn add_duration(&mut self, duration: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(AnimationTransition::VT_DURATION, duration);
  }
  #[inline]
  pub fn add_delay(&mut self, delay: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(AnimationTransition::VT_DELAY, delay);
  }
  #[inline]
  pub fn add_easing(&mut self, easing: flatbuffers::WIPOffset<Easing<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Easing>>(AnimationTransition::VT_EASING, easing);
  }
  #[inline]
  pub fn add_reduced_motion(&mut self, reduced_motion: flatbuffers::WIPOffset<ReducedMotion<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ReducedMotion>>(AnimationTransition::VT_REDUCED_MOTION, reduced_motion);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AnimationTransitionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AnimationTransitionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AnimationTransition<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AnimationTransition::VT_NODE_ID,"node_id");
    self.fbb_.required(o, AnimationTransition::VT_TARGET_NODE_ID,"target_node_id");
    self.fbb_.required(o, AnimationTransition::VT_PROPERTIES,"properties");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for AnimationTransition<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("AnimationTransition");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("target_node_id", &self.target_node_id());
      ds.field("trigger_state_machine", &self.trigger_state_machine());
      ds.field("trigger_event", &self.trigger_event());
      ds.field("properties", &self.properties());
      ds.field("duration", &self.duration());
      ds.field("delay", &self.delay());
      ds.field("easing", &self.easing());
      ds.field("reduced_motion", &self.reduced_motion());
      ds.finish()
  }
}
pub enum SequenceStepOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> SequenceStep<'a> {
  pub const VT_TRANSITION_ID: flatbuffers::VOffsetT = 4;
  pub const VT_DELAY: flatbuffers::VOffsetT = 6;
  pub const VT_PARALLEL: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SequenceStep { _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 SequenceStepArgs<'args>
  ) -> flatbuffers::WIPOffset<SequenceStep<'bldr>> {
    let mut builder = SequenceStepBuilder::new(_fbb);
    if let Some(x) = args.delay { builder.add_delay(x); }
    if let Some(x) = args.transition_id { builder.add_transition_id(x); }
    builder.add_parallel(args.parallel);
    builder.finish()
  }


  /// Reference to an AnimationTransition node.
  #[inline]
  pub fn transition_id(&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>>(SequenceStep::VT_TRANSITION_ID, None).unwrap()}
  }
  /// Delay before this step starts (relative to sequence start or previous step).
  #[inline]
  pub fn delay(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(SequenceStep::VT_DELAY, None)}
  }
  /// If true, this step starts at the same time as the previous step (parallel).
  #[inline]
  pub fn parallel(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SequenceStep::VT_PARALLEL, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for SequenceStep<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("transition_id", Self::VT_TRANSITION_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("delay", Self::VT_DELAY, false)?
     .visit_field::<bool>("parallel", Self::VT_PARALLEL, false)?
     .finish();
    Ok(())
  }
}
pub struct SequenceStepArgs<'a> {
    pub transition_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub delay: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub parallel: bool,
}
impl<'a> Default for SequenceStepArgs<'a> {
  #[inline]
  fn default() -> Self {
    SequenceStepArgs {
      transition_id: None, // required field
      delay: None,
      parallel: false,
    }
  }
}

pub struct SequenceStepBuilder<'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> SequenceStepBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_transition_id(&mut self, transition_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SequenceStep::VT_TRANSITION_ID, transition_id);
  }
  #[inline]
  pub fn add_delay(&mut self, delay: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(SequenceStep::VT_DELAY, delay);
  }
  #[inline]
  pub fn add_parallel(&mut self, parallel: bool) {
    self.fbb_.push_slot::<bool>(SequenceStep::VT_PARALLEL, parallel, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SequenceStepBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SequenceStepBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SequenceStep<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SequenceStep::VT_TRANSITION_ID,"transition_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Sequence<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_STEPS: flatbuffers::VOffsetT = 8;
  pub const VT_STAGGER: flatbuffers::VOffsetT = 10;
  pub const VT_ITERATIONS: flatbuffers::VOffsetT = 12;
  pub const VT_ALTERNATE: flatbuffers::VOffsetT = 14;
  pub const VT_REDUCED_MOTION: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Sequence { _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 SequenceArgs<'args>
  ) -> flatbuffers::WIPOffset<Sequence<'bldr>> {
    let mut builder = SequenceBuilder::new(_fbb);
    if let Some(x) = args.reduced_motion { builder.add_reduced_motion(x); }
    builder.add_iterations(args.iterations);
    if let Some(x) = args.stagger { builder.add_stagger(x); }
    if let Some(x) = args.steps { builder.add_steps(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_alternate(args.alternate);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(Sequence::VT_NODE_ID, None).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>>(Sequence::VT_NAME, None)}
  }
  #[inline]
  pub fn steps(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SequenceStep<'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<SequenceStep>>>>(Sequence::VT_STEPS, None).unwrap()}
  }
  /// Stagger delay between sequential elements (e.g., for list entrance).
  #[inline]
  pub fn stagger(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(Sequence::VT_STAGGER, None)}
  }
  /// Number of times to play (0 = infinite).
  #[inline]
  pub fn iterations(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(Sequence::VT_ITERATIONS, Some(1)).unwrap()}
  }
  /// Whether to reverse on alternate iterations.
  #[inline]
  pub fn alternate(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Sequence::VT_ALTERNATE, Some(false)).unwrap()}
  }
  /// Reduced motion alternative for the entire sequence.
  #[inline]
  pub fn reduced_motion(&self) -> Option<ReducedMotion<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ReducedMotion>>(Sequence::VT_REDUCED_MOTION, None)}
  }
}

impl flatbuffers::Verifiable for Sequence<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SequenceStep>>>>("steps", Self::VT_STEPS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("stagger", Self::VT_STAGGER, false)?
     .visit_field::<i32>("iterations", Self::VT_ITERATIONS, false)?
     .visit_field::<bool>("alternate", Self::VT_ALTERNATE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ReducedMotion>>("reduced_motion", Self::VT_REDUCED_MOTION, false)?
     .finish();
    Ok(())
  }
}
pub struct SequenceArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub steps: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SequenceStep<'a>>>>>,
    pub stagger: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub iterations: i32,
    pub alternate: bool,
    pub reduced_motion: Option<flatbuffers::WIPOffset<ReducedMotion<'a>>>,
}
impl<'a> Default for SequenceArgs<'a> {
  #[inline]
  fn default() -> Self {
    SequenceArgs {
      node_id: None, // required field
      name: None,
      steps: None, // required field
      stagger: None,
      iterations: 1,
      alternate: false,
      reduced_motion: None,
    }
  }
}

pub struct SequenceBuilder<'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> SequenceBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Sequence::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Sequence::VT_NAME, name);
  }
  #[inline]
  pub fn add_steps(&mut self, steps: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<SequenceStep<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Sequence::VT_STEPS, steps);
  }
  #[inline]
  pub fn add_stagger(&mut self, stagger: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(Sequence::VT_STAGGER, stagger);
  }
  #[inline]
  pub fn add_iterations(&mut self, iterations: i32) {
    self.fbb_.push_slot::<i32>(Sequence::VT_ITERATIONS, iterations, 1);
  }
  #[inline]
  pub fn add_alternate(&mut self, alternate: bool) {
    self.fbb_.push_slot::<bool>(Sequence::VT_ALTERNATE, alternate, false);
  }
  #[inline]
  pub fn add_reduced_motion(&mut self, reduced_motion: flatbuffers::WIPOffset<ReducedMotion<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ReducedMotion>>(Sequence::VT_REDUCED_MOTION, reduced_motion);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SequenceBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SequenceBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Sequence<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Sequence::VT_NODE_ID,"node_id");
    self.fbb_.required(o, Sequence::VT_STEPS,"steps");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for Sequence<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("Sequence");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("steps", &self.steps());
      ds.field("stagger", &self.stagger());
      ds.field("iterations", &self.iterations());
      ds.field("alternate", &self.alternate());
      ds.field("reduced_motion", &self.reduced_motion());
      ds.finish()
  }
}
pub enum GestureHandlerOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> GestureHandler<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_GESTURE_TYPE: flatbuffers::VOffsetT = 8;
  pub const VT_TRIGGER_EVENT: flatbuffers::VOffsetT = 10;
  pub const VT_TRIGGER_STATE_MACHINE: flatbuffers::VOffsetT = 12;
  pub const VT_CONTINUOUS_PROPERTY: flatbuffers::VOffsetT = 14;
  pub const VT_CONTINUOUS_AXIS: flatbuffers::VOffsetT = 16;
  pub const VT_KEYBOARD_KEY: flatbuffers::VOffsetT = 18;
  pub const VT_KEYBOARD_MODIFIER: flatbuffers::VOffsetT = 20;
  pub const VT_THRESHOLD_PX: flatbuffers::VOffsetT = 22;
  pub const VT_VELOCITY_THRESHOLD: flatbuffers::VOffsetT = 24;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    GestureHandler { _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 GestureHandlerArgs<'args>
  ) -> flatbuffers::WIPOffset<GestureHandler<'bldr>> {
    let mut builder = GestureHandlerBuilder::new(_fbb);
    builder.add_velocity_threshold(args.velocity_threshold);
    builder.add_threshold_px(args.threshold_px);
    if let Some(x) = args.keyboard_modifier { builder.add_keyboard_modifier(x); }
    if let Some(x) = args.keyboard_key { builder.add_keyboard_key(x); }
    if let Some(x) = args.continuous_axis { builder.add_continuous_axis(x); }
    if let Some(x) = args.continuous_property { builder.add_continuous_property(x); }
    if let Some(x) = args.trigger_state_machine { builder.add_trigger_state_machine(x); }
    if let Some(x) = args.trigger_event { builder.add_trigger_event(x); }
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_gesture_type(args.gesture_type);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(GestureHandler::VT_NODE_ID, None).unwrap()}
  }
  /// Target node that receives the gesture.
  #[inline]
  pub fn target_node_id(&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>>(GestureHandler::VT_TARGET_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn gesture_type(&self) -> GestureType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<GestureType>(GestureHandler::VT_GESTURE_TYPE, Some(GestureType::Tap)).unwrap()}
  }
  /// For tap/click: which state machine event to fire.
  #[inline]
  pub fn trigger_event(&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>>(GestureHandler::VT_TRIGGER_EVENT, None)}
  }
  #[inline]
  pub fn trigger_state_machine(&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>>(GestureHandler::VT_TRIGGER_STATE_MACHINE, None)}
  }
  /// For drag/continuous: property to update and value mapping.
  #[inline]
  pub fn continuous_property(&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>>(GestureHandler::VT_CONTINUOUS_PROPERTY, None)}
  }
  #[inline]
  pub fn continuous_axis(&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>>(GestureHandler::VT_CONTINUOUS_AXIS, None)}
  }
  /// Keyboard equivalent (required by validator for accessibility).
  #[inline]
  pub fn keyboard_key(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(GestureHandler::VT_KEYBOARD_KEY, None)}
  }
  #[inline]
  pub fn keyboard_modifier(&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>>(GestureHandler::VT_KEYBOARD_MODIFIER, None)}
  }
  /// Gesture thresholds.
  #[inline]
  pub fn threshold_px(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(GestureHandler::VT_THRESHOLD_PX, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn velocity_threshold(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(GestureHandler::VT_VELOCITY_THRESHOLD, Some(0.0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for GestureHandler<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<GestureType>("gesture_type", Self::VT_GESTURE_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("trigger_event", Self::VT_TRIGGER_EVENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("trigger_state_machine", Self::VT_TRIGGER_STATE_MACHINE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("continuous_property", Self::VT_CONTINUOUS_PROPERTY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("continuous_axis", Self::VT_CONTINUOUS_AXIS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("keyboard_key", Self::VT_KEYBOARD_KEY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("keyboard_modifier", Self::VT_KEYBOARD_MODIFIER, false)?
     .visit_field::<f32>("threshold_px", Self::VT_THRESHOLD_PX, false)?
     .visit_field::<f32>("velocity_threshold", Self::VT_VELOCITY_THRESHOLD, false)?
     .finish();
    Ok(())
  }
}
pub struct GestureHandlerArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub gesture_type: GestureType,
    pub trigger_event: Option<flatbuffers::WIPOffset<&'a str>>,
    pub trigger_state_machine: Option<flatbuffers::WIPOffset<&'a str>>,
    pub continuous_property: Option<flatbuffers::WIPOffset<&'a str>>,
    pub continuous_axis: Option<flatbuffers::WIPOffset<&'a str>>,
    pub keyboard_key: Option<flatbuffers::WIPOffset<&'a str>>,
    pub keyboard_modifier: Option<flatbuffers::WIPOffset<&'a str>>,
    pub threshold_px: f32,
    pub velocity_threshold: f32,
}
impl<'a> Default for GestureHandlerArgs<'a> {
  #[inline]
  fn default() -> Self {
    GestureHandlerArgs {
      node_id: None, // required field
      target_node_id: None, // required field
      gesture_type: GestureType::Tap,
      trigger_event: None,
      trigger_state_machine: None,
      continuous_property: None,
      continuous_axis: None,
      keyboard_key: None,
      keyboard_modifier: None,
      threshold_px: 0.0,
      velocity_threshold: 0.0,
    }
  }
}

pub struct GestureHandlerBuilder<'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> GestureHandlerBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn add_gesture_type(&mut self, gesture_type: GestureType) {
    self.fbb_.push_slot::<GestureType>(GestureHandler::VT_GESTURE_TYPE, gesture_type, GestureType::Tap);
  }
  #[inline]
  pub fn add_trigger_event(&mut self, trigger_event: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_TRIGGER_EVENT, trigger_event);
  }
  #[inline]
  pub fn add_trigger_state_machine(&mut self, trigger_state_machine: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_TRIGGER_STATE_MACHINE, trigger_state_machine);
  }
  #[inline]
  pub fn add_continuous_property(&mut self, continuous_property: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_CONTINUOUS_PROPERTY, continuous_property);
  }
  #[inline]
  pub fn add_continuous_axis(&mut self, continuous_axis: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_CONTINUOUS_AXIS, continuous_axis);
  }
  #[inline]
  pub fn add_keyboard_key(&mut self, keyboard_key: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_KEYBOARD_KEY, keyboard_key);
  }
  #[inline]
  pub fn add_keyboard_modifier(&mut self, keyboard_modifier: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(GestureHandler::VT_KEYBOARD_MODIFIER, keyboard_modifier);
  }
  #[inline]
  pub fn add_threshold_px(&mut self, threshold_px: f32) {
    self.fbb_.push_slot::<f32>(GestureHandler::VT_THRESHOLD_PX, threshold_px, 0.0);
  }
  #[inline]
  pub fn add_velocity_threshold(&mut self, velocity_threshold: f32) {
    self.fbb_.push_slot::<f32>(GestureHandler::VT_VELOCITY_THRESHOLD, velocity_threshold, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GestureHandlerBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    GestureHandlerBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<GestureHandler<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, GestureHandler::VT_NODE_ID,"node_id");
    self.fbb_.required(o, GestureHandler::VT_TARGET_NODE_ID,"target_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for GestureHandler<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("GestureHandler");
      ds.field("node_id", &self.node_id());
      ds.field("target_node_id", &self.target_node_id());
      ds.field("gesture_type", &self.gesture_type());
      ds.field("trigger_event", &self.trigger_event());
      ds.field("trigger_state_machine", &self.trigger_state_machine());
      ds.field("continuous_property", &self.continuous_property());
      ds.field("continuous_axis", &self.continuous_axis());
      ds.field("keyboard_key", &self.keyboard_key());
      ds.field("keyboard_modifier", &self.keyboard_modifier());
      ds.field("threshold_px", &self.threshold_px());
      ds.field("velocity_threshold", &self.velocity_threshold());
      ds.finish()
  }
}
pub enum ScrollBindingOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ScrollBinding<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_SCROLL_TRIGGER: flatbuffers::VOffsetT = 8;
  pub const VT_SCROLL_AXIS: flatbuffers::VOffsetT = 10;
  pub const VT_RANGE_START: flatbuffers::VOffsetT = 12;
  pub const VT_RANGE_END: flatbuffers::VOffsetT = 14;
  pub const VT_PROPERTIES: flatbuffers::VOffsetT = 16;
  pub const VT_SCROLL_CONTAINER_ID: flatbuffers::VOffsetT = 18;
  pub const VT_REDUCED_MOTION: flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ScrollBinding { _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 ScrollBindingArgs<'args>
  ) -> flatbuffers::WIPOffset<ScrollBinding<'bldr>> {
    let mut builder = ScrollBindingBuilder::new(_fbb);
    if let Some(x) = args.reduced_motion { builder.add_reduced_motion(x); }
    if let Some(x) = args.scroll_container_id { builder.add_scroll_container_id(x); }
    if let Some(x) = args.properties { builder.add_properties(x); }
    builder.add_range_end(args.range_end);
    builder.add_range_start(args.range_start);
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_scroll_axis(args.scroll_axis);
    builder.add_scroll_trigger(args.scroll_trigger);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ScrollBinding::VT_NODE_ID, None).unwrap()}
  }
  /// Target node whose properties are scroll-linked.
  #[inline]
  pub fn target_node_id(&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>>(ScrollBinding::VT_TARGET_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn scroll_trigger(&self) -> ScrollTrigger {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ScrollTrigger>(ScrollBinding::VT_SCROLL_TRIGGER, Some(ScrollTrigger::ViewProgress)).unwrap()}
  }
  #[inline]
  pub fn scroll_axis(&self) -> ScrollAxis {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ScrollAxis>(ScrollBinding::VT_SCROLL_AXIS, Some(ScrollAxis::Vertical)).unwrap()}
  }
  /// Range of scroll progress that maps to animation (0.0 to 1.0).
  #[inline]
  pub fn range_start(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ScrollBinding::VT_RANGE_START, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn range_end(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ScrollBinding::VT_RANGE_END, Some(1.0)).unwrap()}
  }
  /// Properties to animate over the scroll range.
  #[inline]
  pub fn properties(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'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<AnimatedProperty>>>>(ScrollBinding::VT_PROPERTIES, None).unwrap()}
  }
  /// Optional scroll container (default: nearest scrollable ancestor).
  #[inline]
  pub fn scroll_container_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(ScrollBinding::VT_SCROLL_CONTAINER_ID, None)}
  }
  /// Reduced motion: if true, skip scroll-linked animation entirely.
  #[inline]
  pub fn reduced_motion(&self) -> Option<ReducedMotion<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ReducedMotion>>(ScrollBinding::VT_REDUCED_MOTION, None)}
  }
}

impl flatbuffers::Verifiable for ScrollBinding<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<ScrollTrigger>("scroll_trigger", Self::VT_SCROLL_TRIGGER, false)?
     .visit_field::<ScrollAxis>("scroll_axis", Self::VT_SCROLL_AXIS, false)?
     .visit_field::<f32>("range_start", Self::VT_RANGE_START, false)?
     .visit_field::<f32>("range_end", Self::VT_RANGE_END, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AnimatedProperty>>>>("properties", Self::VT_PROPERTIES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("scroll_container_id", Self::VT_SCROLL_CONTAINER_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ReducedMotion>>("reduced_motion", Self::VT_REDUCED_MOTION, false)?
     .finish();
    Ok(())
  }
}
pub struct ScrollBindingArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub scroll_trigger: ScrollTrigger,
    pub scroll_axis: ScrollAxis,
    pub range_start: f32,
    pub range_end: f32,
    pub properties: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'a>>>>>,
    pub scroll_container_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub reduced_motion: Option<flatbuffers::WIPOffset<ReducedMotion<'a>>>,
}
impl<'a> Default for ScrollBindingArgs<'a> {
  #[inline]
  fn default() -> Self {
    ScrollBindingArgs {
      node_id: None, // required field
      target_node_id: None, // required field
      scroll_trigger: ScrollTrigger::ViewProgress,
      scroll_axis: ScrollAxis::Vertical,
      range_start: 0.0,
      range_end: 1.0,
      properties: None, // required field
      scroll_container_id: None,
      reduced_motion: None,
    }
  }
}

pub struct ScrollBindingBuilder<'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> ScrollBindingBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ScrollBinding::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ScrollBinding::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn add_scroll_trigger(&mut self, scroll_trigger: ScrollTrigger) {
    self.fbb_.push_slot::<ScrollTrigger>(ScrollBinding::VT_SCROLL_TRIGGER, scroll_trigger, ScrollTrigger::ViewProgress);
  }
  #[inline]
  pub fn add_scroll_axis(&mut self, scroll_axis: ScrollAxis) {
    self.fbb_.push_slot::<ScrollAxis>(ScrollBinding::VT_SCROLL_AXIS, scroll_axis, ScrollAxis::Vertical);
  }
  #[inline]
  pub fn add_range_start(&mut self, range_start: f32) {
    self.fbb_.push_slot::<f32>(ScrollBinding::VT_RANGE_START, range_start, 0.0);
  }
  #[inline]
  pub fn add_range_end(&mut self, range_end: f32) {
    self.fbb_.push_slot::<f32>(ScrollBinding::VT_RANGE_END, range_end, 1.0);
  }
  #[inline]
  pub fn add_properties(&mut self, properties: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AnimatedProperty<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ScrollBinding::VT_PROPERTIES, properties);
  }
  #[inline]
  pub fn add_scroll_container_id(&mut self, scroll_container_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ScrollBinding::VT_SCROLL_CONTAINER_ID, scroll_container_id);
  }
  #[inline]
  pub fn add_reduced_motion(&mut self, reduced_motion: flatbuffers::WIPOffset<ReducedMotion<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ReducedMotion>>(ScrollBinding::VT_REDUCED_MOTION, reduced_motion);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ScrollBindingBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ScrollBindingBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ScrollBinding<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ScrollBinding::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ScrollBinding::VT_TARGET_NODE_ID,"target_node_id");
    self.fbb_.required(o, ScrollBinding::VT_PROPERTIES,"properties");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ScrollBinding<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ScrollBinding");
      ds.field("node_id", &self.node_id());
      ds.field("target_node_id", &self.target_node_id());
      ds.field("scroll_trigger", &self.scroll_trigger());
      ds.field("scroll_axis", &self.scroll_axis());
      ds.field("range_start", &self.range_start());
      ds.field("range_end", &self.range_end());
      ds.field("properties", &self.properties());
      ds.field("scroll_container_id", &self.scroll_container_id());
      ds.field("reduced_motion", &self.reduced_motion());
      ds.finish()
  }
}
pub enum PhysicsBodyOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> PhysicsBody<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_STIFFNESS: flatbuffers::VOffsetT = 8;
  pub const VT_DAMPING: flatbuffers::VOffsetT = 10;
  pub const VT_MASS: flatbuffers::VOffsetT = 12;
  pub const VT_FRICTION: flatbuffers::VOffsetT = 14;
  pub const VT_RESTITUTION: flatbuffers::VOffsetT = 16;
  pub const VT_INTERRUPTIBLE: flatbuffers::VOffsetT = 18;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    PhysicsBody { _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 PhysicsBodyArgs<'args>
  ) -> flatbuffers::WIPOffset<PhysicsBody<'bldr>> {
    let mut builder = PhysicsBodyBuilder::new(_fbb);
    builder.add_restitution(args.restitution);
    builder.add_friction(args.friction);
    builder.add_mass(args.mass);
    builder.add_damping(args.damping);
    builder.add_stiffness(args.stiffness);
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_interruptible(args.interruptible);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(PhysicsBody::VT_NODE_ID, None).unwrap()}
  }
  /// Target node to apply physics to.
  #[inline]
  pub fn target_node_id(&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>>(PhysicsBody::VT_TARGET_NODE_ID, None).unwrap()}
  }
  /// Spring parameters (the primary use case).
  #[inline]
  pub fn stiffness(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(PhysicsBody::VT_STIFFNESS, Some(300.0)).unwrap()}
  }
  #[inline]
  pub fn damping(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(PhysicsBody::VT_DAMPING, Some(25.0)).unwrap()}
  }
  #[inline]
  pub fn mass(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(PhysicsBody::VT_MASS, Some(1.0)).unwrap()}
  }
  /// Friction for momentum decay (0.0 = no friction, 1.0 = instant stop).
  #[inline]
  pub fn friction(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(PhysicsBody::VT_FRICTION, Some(0.05)).unwrap()}
  }
  /// Restitution / bounciness (0.0 = no bounce, 1.0 = perfect bounce).
  #[inline]
  pub fn restitution(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(PhysicsBody::VT_RESTITUTION, Some(0.0)).unwrap()}
  }
  /// If true, the compiler emits a per-frame rAF stepper instead of
  /// pre-computed CSS linear() easing. Needed when the animation can
  /// be interrupted mid-flight (e.g., rapid hover/unhover).
  #[inline]
  pub fn interruptible(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(PhysicsBody::VT_INTERRUPTIBLE, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for PhysicsBody<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<f32>("stiffness", Self::VT_STIFFNESS, false)?
     .visit_field::<f32>("damping", Self::VT_DAMPING, false)?
     .visit_field::<f32>("mass", Self::VT_MASS, false)?
     .visit_field::<f32>("friction", Self::VT_FRICTION, false)?
     .visit_field::<f32>("restitution", Self::VT_RESTITUTION, false)?
     .visit_field::<bool>("interruptible", Self::VT_INTERRUPTIBLE, false)?
     .finish();
    Ok(())
  }
}
pub struct PhysicsBodyArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub stiffness: f32,
    pub damping: f32,
    pub mass: f32,
    pub friction: f32,
    pub restitution: f32,
    pub interruptible: bool,
}
impl<'a> Default for PhysicsBodyArgs<'a> {
  #[inline]
  fn default() -> Self {
    PhysicsBodyArgs {
      node_id: None, // required field
      target_node_id: None, // required field
      stiffness: 300.0,
      damping: 25.0,
      mass: 1.0,
      friction: 0.05,
      restitution: 0.0,
      interruptible: false,
    }
  }
}

pub struct PhysicsBodyBuilder<'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> PhysicsBodyBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PhysicsBody::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PhysicsBody::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn add_stiffness(&mut self, stiffness: f32) {
    self.fbb_.push_slot::<f32>(PhysicsBody::VT_STIFFNESS, stiffness, 300.0);
  }
  #[inline]
  pub fn add_damping(&mut self, damping: f32) {
    self.fbb_.push_slot::<f32>(PhysicsBody::VT_DAMPING, damping, 25.0);
  }
  #[inline]
  pub fn add_mass(&mut self, mass: f32) {
    self.fbb_.push_slot::<f32>(PhysicsBody::VT_MASS, mass, 1.0);
  }
  #[inline]
  pub fn add_friction(&mut self, friction: f32) {
    self.fbb_.push_slot::<f32>(PhysicsBody::VT_FRICTION, friction, 0.05);
  }
  #[inline]
  pub fn add_restitution(&mut self, restitution: f32) {
    self.fbb_.push_slot::<f32>(PhysicsBody::VT_RESTITUTION, restitution, 0.0);
  }
  #[inline]
  pub fn add_interruptible(&mut self, interruptible: bool) {
    self.fbb_.push_slot::<bool>(PhysicsBody::VT_INTERRUPTIBLE, interruptible, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PhysicsBodyBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PhysicsBodyBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<PhysicsBody<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, PhysicsBody::VT_NODE_ID,"node_id");
    self.fbb_.required(o, PhysicsBody::VT_TARGET_NODE_ID,"target_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for PhysicsBody<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("PhysicsBody");
      ds.field("node_id", &self.node_id());
      ds.field("target_node_id", &self.target_node_id());
      ds.field("stiffness", &self.stiffness());
      ds.field("damping", &self.damping());
      ds.field("mass", &self.mass());
      ds.field("friction", &self.friction());
      ds.field("restitution", &self.restitution());
      ds.field("interruptible", &self.interruptible());
      ds.finish()
  }
}
pub enum ReducedMotionOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ReducedMotion<'a> {
  pub const VT_STRATEGY: flatbuffers::VOffsetT = 4;
  pub const VT_SIMPLIFIED_PROPERTIES: flatbuffers::VOffsetT = 6;
  pub const VT_REDUCED_DURATION: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ReducedMotion { _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 ReducedMotionArgs<'args>
  ) -> flatbuffers::WIPOffset<ReducedMotion<'bldr>> {
    let mut builder = ReducedMotionBuilder::new(_fbb);
    if let Some(x) = args.reduced_duration { builder.add_reduced_duration(x); }
    if let Some(x) = args.simplified_properties { builder.add_simplified_properties(x); }
    builder.add_strategy(args.strategy);
    builder.finish()
  }


  #[inline]
  pub fn strategy(&self) -> ReducedMotionStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ReducedMotionStrategy>(ReducedMotion::VT_STRATEGY, Some(ReducedMotionStrategy::Remove)).unwrap()}
  }
  /// For Simplify: replacement properties to animate instead.
  #[inline]
  pub fn simplified_properties(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'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<AnimatedProperty>>>>(ReducedMotion::VT_SIMPLIFIED_PROPERTIES, None)}
  }
  /// For ReduceDuration: the reduced duration (e.g., 1ms for instant).
  #[inline]
  pub fn reduced_duration(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(ReducedMotion::VT_REDUCED_DURATION, None)}
  }
}

impl flatbuffers::Verifiable for ReducedMotion<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<ReducedMotionStrategy>("strategy", Self::VT_STRATEGY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AnimatedProperty>>>>("simplified_properties", Self::VT_SIMPLIFIED_PROPERTIES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("reduced_duration", Self::VT_REDUCED_DURATION, false)?
     .finish();
    Ok(())
  }
}
pub struct ReducedMotionArgs<'a> {
    pub strategy: ReducedMotionStrategy,
    pub simplified_properties: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AnimatedProperty<'a>>>>>,
    pub reduced_duration: Option<flatbuffers::WIPOffset<Duration<'a>>>,
}
impl<'a> Default for ReducedMotionArgs<'a> {
  #[inline]
  fn default() -> Self {
    ReducedMotionArgs {
      strategy: ReducedMotionStrategy::Remove,
      simplified_properties: None,
      reduced_duration: None,
    }
  }
}

pub struct ReducedMotionBuilder<'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> ReducedMotionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_strategy(&mut self, strategy: ReducedMotionStrategy) {
    self.fbb_.push_slot::<ReducedMotionStrategy>(ReducedMotion::VT_STRATEGY, strategy, ReducedMotionStrategy::Remove);
  }
  #[inline]
  pub fn add_simplified_properties(&mut self, simplified_properties: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AnimatedProperty<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ReducedMotion::VT_SIMPLIFIED_PROPERTIES, simplified_properties);
  }
  #[inline]
  pub fn add_reduced_duration(&mut self, reduced_duration: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(ReducedMotion::VT_REDUCED_DURATION, reduced_duration);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ReducedMotionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ReducedMotionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ReducedMotion<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SharedElementPair<'a> {
  pub const VT_TRANSITION_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_SOURCE_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SharedElementPair { _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 SharedElementPairArgs<'args>
  ) -> flatbuffers::WIPOffset<SharedElementPair<'bldr>> {
    let mut builder = SharedElementPairBuilder::new(_fbb);
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.source_node_id { builder.add_source_node_id(x); }
    if let Some(x) = args.transition_name { builder.add_transition_name(x); }
    builder.finish()
  }


  #[inline]
  pub fn transition_name(&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>>(SharedElementPair::VT_TRANSITION_NAME, None).unwrap()}
  }
  #[inline]
  pub fn source_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(SharedElementPair::VT_SOURCE_NODE_ID, None)}
  }
  #[inline]
  pub fn target_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(SharedElementPair::VT_TARGET_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for SharedElementPair<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("transition_name", Self::VT_TRANSITION_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("source_node_id", Self::VT_SOURCE_NODE_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct SharedElementPairArgs<'a> {
    pub transition_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for SharedElementPairArgs<'a> {
  #[inline]
  fn default() -> Self {
    SharedElementPairArgs {
      transition_name: None, // required field
      source_node_id: None,
      target_node_id: None,
    }
  }
}

pub struct SharedElementPairBuilder<'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> SharedElementPairBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_transition_name(&mut self, transition_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SharedElementPair::VT_TRANSITION_NAME, transition_name);
  }
  #[inline]
  pub fn add_source_node_id(&mut self, source_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SharedElementPair::VT_SOURCE_NODE_ID, source_node_id);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SharedElementPair::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SharedElementPairBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SharedElementPairBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SharedElementPair<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SharedElementPair::VT_TRANSITION_NAME,"transition_name");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RouteGuard<'a> {
  pub const VT_REQUIRES_AUTH: flatbuffers::VOffsetT = 4;
  pub const VT_REQUIRED_ROLES: flatbuffers::VOffsetT = 6;
  pub const VT_REDIRECT_ON_FAIL: flatbuffers::VOffsetT = 8;
  pub const VT_CUSTOM_GUARD: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RouteGuard { _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 RouteGuardArgs<'args>
  ) -> flatbuffers::WIPOffset<RouteGuard<'bldr>> {
    let mut builder = RouteGuardBuilder::new(_fbb);
    if let Some(x) = args.custom_guard { builder.add_custom_guard(x); }
    if let Some(x) = args.redirect_on_fail { builder.add_redirect_on_fail(x); }
    if let Some(x) = args.required_roles { builder.add_required_roles(x); }
    builder.add_requires_auth(args.requires_auth);
    builder.finish()
  }


  #[inline]
  pub fn requires_auth(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RouteGuard::VT_REQUIRES_AUTH, Some(false)).unwrap()}
  }
  #[inline]
  pub fn required_roles(&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>>>>(RouteGuard::VT_REQUIRED_ROLES, None)}
  }
  #[inline]
  pub fn redirect_on_fail(&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>>(RouteGuard::VT_REDIRECT_ON_FAIL, None)}
  }
  #[inline]
  pub fn custom_guard(&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>>(RouteGuard::VT_CUSTOM_GUARD, None)}
  }
}

impl flatbuffers::Verifiable for RouteGuard<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<bool>("requires_auth", Self::VT_REQUIRES_AUTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("required_roles", Self::VT_REQUIRED_ROLES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("redirect_on_fail", Self::VT_REDIRECT_ON_FAIL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("custom_guard", Self::VT_CUSTOM_GUARD, false)?
     .finish();
    Ok(())
  }
}
pub struct RouteGuardArgs<'a> {
    pub requires_auth: bool,
    pub required_roles: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub redirect_on_fail: Option<flatbuffers::WIPOffset<&'a str>>,
    pub custom_guard: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for RouteGuardArgs<'a> {
  #[inline]
  fn default() -> Self {
    RouteGuardArgs {
      requires_auth: false,
      required_roles: None,
      redirect_on_fail: None,
      custom_guard: None,
    }
  }
}

pub struct RouteGuardBuilder<'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> RouteGuardBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_requires_auth(&mut self, requires_auth: bool) {
    self.fbb_.push_slot::<bool>(RouteGuard::VT_REQUIRES_AUTH, requires_auth, false);
  }
  #[inline]
  pub fn add_required_roles(&mut self, required_roles: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteGuard::VT_REQUIRED_ROLES, required_roles);
  }
  #[inline]
  pub fn add_redirect_on_fail(&mut self, redirect_on_fail: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteGuard::VT_REDIRECT_ON_FAIL, redirect_on_fail);
  }
  #[inline]
  pub fn add_custom_guard(&mut self, custom_guard: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteGuard::VT_CUSTOM_GUARD, custom_guard);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RouteGuardBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RouteGuardBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RouteGuard<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RouteTransitionConfig<'a> {
  pub const VT_TRANSITION_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_DURATION: flatbuffers::VOffsetT = 6;
  pub const VT_EASING: flatbuffers::VOffsetT = 8;
  pub const VT_SLIDE_DIRECTION: flatbuffers::VOffsetT = 10;
  pub const VT_SHARED_ELEMENTS: flatbuffers::VOffsetT = 12;
  pub const VT_CUSTOM_SEQUENCE_ID: flatbuffers::VOffsetT = 14;
  pub const VT_REDUCED_MOTION: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RouteTransitionConfig { _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 RouteTransitionConfigArgs<'args>
  ) -> flatbuffers::WIPOffset<RouteTransitionConfig<'bldr>> {
    let mut builder = RouteTransitionConfigBuilder::new(_fbb);
    if let Some(x) = args.reduced_motion { builder.add_reduced_motion(x); }
    if let Some(x) = args.custom_sequence_id { builder.add_custom_sequence_id(x); }
    if let Some(x) = args.shared_elements { builder.add_shared_elements(x); }
    if let Some(x) = args.easing { builder.add_easing(x); }
    if let Some(x) = args.duration { builder.add_duration(x); }
    builder.add_slide_direction(args.slide_direction);
    builder.add_transition_type(args.transition_type);
    builder.finish()
  }


  #[inline]
  pub fn transition_type(&self) -> RouteTransitionType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<RouteTransitionType>(RouteTransitionConfig::VT_TRANSITION_TYPE, Some(RouteTransitionType::None)).unwrap()}
  }
  #[inline]
  pub fn duration(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(RouteTransitionConfig::VT_DURATION, None)}
  }
  #[inline]
  pub fn easing(&self) -> Option<Easing<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Easing>>(RouteTransitionConfig::VT_EASING, None)}
  }
  #[inline]
  pub fn slide_direction(&self) -> SlideDirection {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<SlideDirection>(RouteTransitionConfig::VT_SLIDE_DIRECTION, Some(SlideDirection::Left)).unwrap()}
  }
  #[inline]
  pub fn shared_elements(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SharedElementPair<'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<SharedElementPair>>>>(RouteTransitionConfig::VT_SHARED_ELEMENTS, None)}
  }
  #[inline]
  pub fn custom_sequence_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(RouteTransitionConfig::VT_CUSTOM_SEQUENCE_ID, None)}
  }
  #[inline]
  pub fn reduced_motion(&self) -> Option<ReducedMotion<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ReducedMotion>>(RouteTransitionConfig::VT_REDUCED_MOTION, None)}
  }
}

impl flatbuffers::Verifiable for RouteTransitionConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<RouteTransitionType>("transition_type", Self::VT_TRANSITION_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("duration", Self::VT_DURATION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Easing>>("easing", Self::VT_EASING, false)?
     .visit_field::<SlideDirection>("slide_direction", Self::VT_SLIDE_DIRECTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SharedElementPair>>>>("shared_elements", Self::VT_SHARED_ELEMENTS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("custom_sequence_id", Self::VT_CUSTOM_SEQUENCE_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ReducedMotion>>("reduced_motion", Self::VT_REDUCED_MOTION, false)?
     .finish();
    Ok(())
  }
}
pub struct RouteTransitionConfigArgs<'a> {
    pub transition_type: RouteTransitionType,
    pub duration: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub easing: Option<flatbuffers::WIPOffset<Easing<'a>>>,
    pub slide_direction: SlideDirection,
    pub shared_elements: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SharedElementPair<'a>>>>>,
    pub custom_sequence_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub reduced_motion: Option<flatbuffers::WIPOffset<ReducedMotion<'a>>>,
}
impl<'a> Default for RouteTransitionConfigArgs<'a> {
  #[inline]
  fn default() -> Self {
    RouteTransitionConfigArgs {
      transition_type: RouteTransitionType::None,
      duration: None,
      easing: None,
      slide_direction: SlideDirection::Left,
      shared_elements: None,
      custom_sequence_id: None,
      reduced_motion: None,
    }
  }
}

pub struct RouteTransitionConfigBuilder<'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> RouteTransitionConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_transition_type(&mut self, transition_type: RouteTransitionType) {
    self.fbb_.push_slot::<RouteTransitionType>(RouteTransitionConfig::VT_TRANSITION_TYPE, transition_type, RouteTransitionType::None);
  }
  #[inline]
  pub fn add_duration(&mut self, duration: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(RouteTransitionConfig::VT_DURATION, duration);
  }
  #[inline]
  pub fn add_easing(&mut self, easing: flatbuffers::WIPOffset<Easing<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Easing>>(RouteTransitionConfig::VT_EASING, easing);
  }
  #[inline]
  pub fn add_slide_direction(&mut self, slide_direction: SlideDirection) {
    self.fbb_.push_slot::<SlideDirection>(RouteTransitionConfig::VT_SLIDE_DIRECTION, slide_direction, SlideDirection::Left);
  }
  #[inline]
  pub fn add_shared_elements(&mut self, shared_elements: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<SharedElementPair<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteTransitionConfig::VT_SHARED_ELEMENTS, shared_elements);
  }
  #[inline]
  pub fn add_custom_sequence_id(&mut self, custom_sequence_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteTransitionConfig::VT_CUSTOM_SEQUENCE_ID, custom_sequence_id);
  }
  #[inline]
  pub fn add_reduced_motion(&mut self, reduced_motion: flatbuffers::WIPOffset<ReducedMotion<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ReducedMotion>>(RouteTransitionConfig::VT_REDUCED_MOTION, reduced_motion);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RouteTransitionConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RouteTransitionConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RouteTransitionConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for RouteTransitionConfig<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("RouteTransitionConfig");
      ds.field("transition_type", &self.transition_type());
      ds.field("duration", &self.duration());
      ds.field("easing", &self.easing());
      ds.field("slide_direction", &self.slide_direction());
      ds.field("shared_elements", &self.shared_elements());
      ds.field("custom_sequence_id", &self.custom_sequence_id());
      ds.field("reduced_motion", &self.reduced_motion());
      ds.finish()
  }
}
pub enum RouteEntryOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> RouteEntry<'a> {
  pub const VT_PATH: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_VIEW_ROOT_ID: flatbuffers::VOffsetT = 8;
  pub const VT_GUARD: flatbuffers::VOffsetT = 10;
  pub const VT_PRELOAD_DATA: flatbuffers::VOffsetT = 12;
  pub const VT_TRANSITION: flatbuffers::VOffsetT = 14;
  pub const VT_SITEMAP_PRIORITY: flatbuffers::VOffsetT = 16;
  pub const VT_SITEMAP_CHANGE_FREQ: flatbuffers::VOffsetT = 18;
  pub const VT_SITEMAP_LAST_MODIFIED: flatbuffers::VOffsetT = 20;
  pub const VT_EXCLUDE_FROM_SITEMAP: flatbuffers::VOffsetT = 22;
  pub const VT_CHILDREN: flatbuffers::VOffsetT = 24;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RouteEntry { _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 RouteEntryArgs<'args>
  ) -> flatbuffers::WIPOffset<RouteEntry<'bldr>> {
    let mut builder = RouteEntryBuilder::new(_fbb);
    if let Some(x) = args.children { builder.add_children(x); }
    if let Some(x) = args.sitemap_last_modified { builder.add_sitemap_last_modified(x); }
    builder.add_sitemap_priority(args.sitemap_priority);
    if let Some(x) = args.transition { builder.add_transition(x); }
    if let Some(x) = args.preload_data { builder.add_preload_data(x); }
    if let Some(x) = args.guard { builder.add_guard(x); }
    if let Some(x) = args.view_root_id { builder.add_view_root_id(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.path { builder.add_path(x); }
    builder.add_exclude_from_sitemap(args.exclude_from_sitemap);
    builder.add_sitemap_change_freq(args.sitemap_change_freq);
    builder.finish()
  }


  #[inline]
  pub fn path(&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>>(RouteEntry::VT_PATH, None).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>>(RouteEntry::VT_NAME, None)}
  }
  #[inline]
  pub fn view_root_id(&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>>(RouteEntry::VT_VIEW_ROOT_ID, None).unwrap()}
  }
  #[inline]
  pub fn guard(&self) -> Option<RouteGuard<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RouteGuard>>(RouteEntry::VT_GUARD, None)}
  }
  #[inline]
  pub fn preload_data(&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>>>>(RouteEntry::VT_PRELOAD_DATA, None)}
  }
  #[inline]
  pub fn transition(&self) -> Option<RouteTransitionConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RouteTransitionConfig>>(RouteEntry::VT_TRANSITION, None)}
  }
  #[inline]
  pub fn sitemap_priority(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(RouteEntry::VT_SITEMAP_PRIORITY, Some(0.5)).unwrap()}
  }
  #[inline]
  pub fn sitemap_change_freq(&self) -> ChangeFrequency {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ChangeFrequency>(RouteEntry::VT_SITEMAP_CHANGE_FREQ, Some(ChangeFrequency::Always)).unwrap()}
  }
  #[inline]
  pub fn sitemap_last_modified(&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>>(RouteEntry::VT_SITEMAP_LAST_MODIFIED, None)}
  }
  #[inline]
  pub fn exclude_from_sitemap(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RouteEntry::VT_EXCLUDE_FROM_SITEMAP, Some(false)).unwrap()}
  }
  #[inline]
  pub fn children(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RouteEntry<'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<RouteEntry>>>>(RouteEntry::VT_CHILDREN, None)}
  }
}

impl flatbuffers::Verifiable for RouteEntry<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("path", Self::VT_PATH, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("view_root_id", Self::VT_VIEW_ROOT_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<RouteGuard>>("guard", Self::VT_GUARD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("preload_data", Self::VT_PRELOAD_DATA, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<RouteTransitionConfig>>("transition", Self::VT_TRANSITION, false)?
     .visit_field::<f32>("sitemap_priority", Self::VT_SITEMAP_PRIORITY, false)?
     .visit_field::<ChangeFrequency>("sitemap_change_freq", Self::VT_SITEMAP_CHANGE_FREQ, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("sitemap_last_modified", Self::VT_SITEMAP_LAST_MODIFIED, false)?
     .visit_field::<bool>("exclude_from_sitemap", Self::VT_EXCLUDE_FROM_SITEMAP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RouteEntry>>>>("children", Self::VT_CHILDREN, false)?
     .finish();
    Ok(())
  }
}
pub struct RouteEntryArgs<'a> {
    pub path: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub view_root_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub guard: Option<flatbuffers::WIPOffset<RouteGuard<'a>>>,
    pub preload_data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub transition: Option<flatbuffers::WIPOffset<RouteTransitionConfig<'a>>>,
    pub sitemap_priority: f32,
    pub sitemap_change_freq: ChangeFrequency,
    pub sitemap_last_modified: Option<flatbuffers::WIPOffset<&'a str>>,
    pub exclude_from_sitemap: bool,
    pub children: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RouteEntry<'a>>>>>,
}
impl<'a> Default for RouteEntryArgs<'a> {
  #[inline]
  fn default() -> Self {
    RouteEntryArgs {
      path: None, // required field
      name: None,
      view_root_id: None, // required field
      guard: None,
      preload_data: None,
      transition: None,
      sitemap_priority: 0.5,
      sitemap_change_freq: ChangeFrequency::Always,
      sitemap_last_modified: None,
      exclude_from_sitemap: false,
      children: None,
    }
  }
}

pub struct RouteEntryBuilder<'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> RouteEntryBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_path(&mut self, path: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_PATH, path);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_NAME, name);
  }
  #[inline]
  pub fn add_view_root_id(&mut self, view_root_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_VIEW_ROOT_ID, view_root_id);
  }
  #[inline]
  pub fn add_guard(&mut self, guard: flatbuffers::WIPOffset<RouteGuard<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RouteGuard>>(RouteEntry::VT_GUARD, guard);
  }
  #[inline]
  pub fn add_preload_data(&mut self, preload_data: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_PRELOAD_DATA, preload_data);
  }
  #[inline]
  pub fn add_transition(&mut self, transition: flatbuffers::WIPOffset<RouteTransitionConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RouteTransitionConfig>>(RouteEntry::VT_TRANSITION, transition);
  }
  #[inline]
  pub fn add_sitemap_priority(&mut self, sitemap_priority: f32) {
    self.fbb_.push_slot::<f32>(RouteEntry::VT_SITEMAP_PRIORITY, sitemap_priority, 0.5);
  }
  #[inline]
  pub fn add_sitemap_change_freq(&mut self, sitemap_change_freq: ChangeFrequency) {
    self.fbb_.push_slot::<ChangeFrequency>(RouteEntry::VT_SITEMAP_CHANGE_FREQ, sitemap_change_freq, ChangeFrequency::Always);
  }
  #[inline]
  pub fn add_sitemap_last_modified(&mut self, sitemap_last_modified: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_SITEMAP_LAST_MODIFIED, sitemap_last_modified);
  }
  #[inline]
  pub fn add_exclude_from_sitemap(&mut self, exclude_from_sitemap: bool) {
    self.fbb_.push_slot::<bool>(RouteEntry::VT_EXCLUDE_FROM_SITEMAP, exclude_from_sitemap, false);
  }
  #[inline]
  pub fn add_children(&mut self, children: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<RouteEntry<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteEntry::VT_CHILDREN, children);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RouteEntryBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RouteEntryBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RouteEntry<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RouteEntry::VT_PATH,"path");
    self.fbb_.required(o, RouteEntry::VT_VIEW_ROOT_ID,"view_root_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for RouteEntry<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("RouteEntry");
      ds.field("path", &self.path());
      ds.field("name", &self.name());
      ds.field("view_root_id", &self.view_root_id());
      ds.field("guard", &self.guard());
      ds.field("preload_data", &self.preload_data());
      ds.field("transition", &self.transition());
      ds.field("sitemap_priority", &self.sitemap_priority());
      ds.field("sitemap_change_freq", &self.sitemap_change_freq());
      ds.field("sitemap_last_modified", &self.sitemap_last_modified());
      ds.field("exclude_from_sitemap", &self.exclude_from_sitemap());
      ds.field("children", &self.children());
      ds.finish()
  }
}
pub enum RouteMapOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> RouteMap<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_ROUTES: flatbuffers::VOffsetT = 6;
  pub const VT_NOT_FOUND_ROUTE: flatbuffers::VOffsetT = 8;
  pub const VT_DEFAULT_TRANSITION: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RouteMap { _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 RouteMapArgs<'args>
  ) -> flatbuffers::WIPOffset<RouteMap<'bldr>> {
    let mut builder = RouteMapBuilder::new(_fbb);
    if let Some(x) = args.default_transition { builder.add_default_transition(x); }
    if let Some(x) = args.not_found_route { builder.add_not_found_route(x); }
    if let Some(x) = args.routes { builder.add_routes(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(RouteMap::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn routes(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RouteEntry<'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<RouteEntry>>>>(RouteMap::VT_ROUTES, None).unwrap()}
  }
  #[inline]
  pub fn not_found_route(&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>>(RouteMap::VT_NOT_FOUND_ROUTE, None)}
  }
  #[inline]
  pub fn default_transition(&self) -> Option<RouteTransitionConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RouteTransitionConfig>>(RouteMap::VT_DEFAULT_TRANSITION, None)}
  }
}

impl flatbuffers::Verifiable for RouteMap<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RouteEntry>>>>("routes", Self::VT_ROUTES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("not_found_route", Self::VT_NOT_FOUND_ROUTE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<RouteTransitionConfig>>("default_transition", Self::VT_DEFAULT_TRANSITION, false)?
     .finish();
    Ok(())
  }
}
pub struct RouteMapArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub routes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RouteEntry<'a>>>>>,
    pub not_found_route: Option<flatbuffers::WIPOffset<&'a str>>,
    pub default_transition: Option<flatbuffers::WIPOffset<RouteTransitionConfig<'a>>>,
}
impl<'a> Default for RouteMapArgs<'a> {
  #[inline]
  fn default() -> Self {
    RouteMapArgs {
      node_id: None, // required field
      routes: None, // required field
      not_found_route: None,
      default_transition: None,
    }
  }
}

pub struct RouteMapBuilder<'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> RouteMapBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteMap::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_routes(&mut self, routes: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<RouteEntry<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteMap::VT_ROUTES, routes);
  }
  #[inline]
  pub fn add_not_found_route(&mut self, not_found_route: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RouteMap::VT_NOT_FOUND_ROUTE, not_found_route);
  }
  #[inline]
  pub fn add_default_transition(&mut self, default_transition: flatbuffers::WIPOffset<RouteTransitionConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RouteTransitionConfig>>(RouteMap::VT_DEFAULT_TRANSITION, default_transition);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RouteMapBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RouteMapBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RouteMap<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RouteMap::VT_NODE_ID,"node_id");
    self.fbb_.required(o, RouteMap::VT_ROUTES,"routes");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> State<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_INITIAL: flatbuffers::VOffsetT = 6;
  pub const VT_TERMINAL: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    State { _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 StateArgs<'args>
  ) -> flatbuffers::WIPOffset<State<'bldr>> {
    let mut builder = StateBuilder::new(_fbb);
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_terminal(args.terminal);
    builder.add_initial(args.initial);
    builder.finish()
  }


  #[inline]
  pub fn name(&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>>(State::VT_NAME, None).unwrap()}
  }
  /// If true, this is the initial state of the machine.
  #[inline]
  pub fn initial(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(State::VT_INITIAL, Some(false)).unwrap()}
  }
  /// If true, this is a terminal/final state (no outgoing transitions expected).
  #[inline]
  pub fn terminal(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(State::VT_TERMINAL, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for State<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<bool>("initial", Self::VT_INITIAL, false)?
     .visit_field::<bool>("terminal", Self::VT_TERMINAL, false)?
     .finish();
    Ok(())
  }
}
pub struct StateArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub initial: bool,
    pub terminal: bool,
}
impl<'a> Default for StateArgs<'a> {
  #[inline]
  fn default() -> Self {
    StateArgs {
      name: None, // required field
      initial: false,
      terminal: false,
    }
  }
}

pub struct StateBuilder<'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> StateBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(State::VT_NAME, name);
  }
  #[inline]
  pub fn add_initial(&mut self, initial: bool) {
    self.fbb_.push_slot::<bool>(State::VT_INITIAL, initial, false);
  }
  #[inline]
  pub fn add_terminal(&mut self, terminal: bool) {
    self.fbb_.push_slot::<bool>(State::VT_TERMINAL, terminal, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StateBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    StateBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<State<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, State::VT_NAME,"name");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Transition<'a> {
  pub const VT_EVENT: flatbuffers::VOffsetT = 4;
  pub const VT_FROM: flatbuffers::VOffsetT = 6;
  pub const VT_TO: flatbuffers::VOffsetT = 8;
  pub const VT_GUARD: flatbuffers::VOffsetT = 10;
  pub const VT_EFFECT: flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Transition { _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 TransitionArgs<'args>
  ) -> flatbuffers::WIPOffset<Transition<'bldr>> {
    let mut builder = TransitionBuilder::new(_fbb);
    if let Some(x) = args.effect { builder.add_effect(x); }
    if let Some(x) = args.guard { builder.add_guard(x); }
    if let Some(x) = args.to { builder.add_to(x); }
    if let Some(x) = args.from { builder.add_from(x); }
    if let Some(x) = args.event { builder.add_event(x); }
    builder.finish()
  }


  /// Event name that triggers this transition (e.g., "click", "hover", "submit").
  #[inline]
  pub fn event(&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>>(Transition::VT_EVENT, None).unwrap()}
  }
  /// Source state name.
  #[inline]
  pub fn from(&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>>(Transition::VT_FROM, None).unwrap()}
  }
  /// Target state name.
  #[inline]
  pub fn to(&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>>(Transition::VT_TO, None).unwrap()}
  }
  /// Optional guard condition — reference to a ComputeNode that returns bool.
  #[inline]
  pub fn guard(&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>>(Transition::VT_GUARD, None)}
  }
  /// Optional effect — reference to an EffectNode to execute on transition.
  #[inline]
  pub fn effect(&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>>(Transition::VT_EFFECT, None)}
  }
}

impl flatbuffers::Verifiable for Transition<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("event", Self::VT_EVENT, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("from", Self::VT_FROM, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("to", Self::VT_TO, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("guard", Self::VT_GUARD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("effect", Self::VT_EFFECT, false)?
     .finish();
    Ok(())
  }
}
pub struct TransitionArgs<'a> {
    pub event: Option<flatbuffers::WIPOffset<&'a str>>,
    pub from: Option<flatbuffers::WIPOffset<&'a str>>,
    pub to: Option<flatbuffers::WIPOffset<&'a str>>,
    pub guard: Option<flatbuffers::WIPOffset<&'a str>>,
    pub effect: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for TransitionArgs<'a> {
  #[inline]
  fn default() -> Self {
    TransitionArgs {
      event: None, // required field
      from: None, // required field
      to: None, // required field
      guard: None,
      effect: None,
    }
  }
}

pub struct TransitionBuilder<'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> TransitionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_event(&mut self, event: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Transition::VT_EVENT, event);
  }
  #[inline]
  pub fn add_from(&mut self, from: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Transition::VT_FROM, from);
  }
  #[inline]
  pub fn add_to(&mut self, to: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Transition::VT_TO, to);
  }
  #[inline]
  pub fn add_guard(&mut self, guard: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Transition::VT_GUARD, guard);
  }
  #[inline]
  pub fn add_effect(&mut self, effect: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Transition::VT_EFFECT, effect);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TransitionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TransitionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Transition<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Transition::VT_EVENT,"event");
    self.fbb_.required(o, Transition::VT_FROM,"from");
    self.fbb_.required(o, Transition::VT_TO,"to");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> StateMachine<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_STATES: flatbuffers::VOffsetT = 8;
  pub const VT_TRANSITIONS: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    StateMachine { _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 StateMachineArgs<'args>
  ) -> flatbuffers::WIPOffset<StateMachine<'bldr>> {
    let mut builder = StateMachineBuilder::new(_fbb);
    if let Some(x) = args.transitions { builder.add_transitions(x); }
    if let Some(x) = args.states { builder.add_states(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(StateMachine::VT_NODE_ID, None).unwrap()}
  }
  /// Human-readable name for this machine (e.g., "button-state", "auth-flow").
  #[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>>(StateMachine::VT_NAME, None)}
  }
  #[inline]
  pub fn states(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<State<'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<State>>>>(StateMachine::VT_STATES, None).unwrap()}
  }
  #[inline]
  pub fn transitions(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Transition<'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<Transition>>>>(StateMachine::VT_TRANSITIONS, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for StateMachine<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<State>>>>("states", Self::VT_STATES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Transition>>>>("transitions", Self::VT_TRANSITIONS, true)?
     .finish();
    Ok(())
  }
}
pub struct StateMachineArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub states: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<State<'a>>>>>,
    pub transitions: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Transition<'a>>>>>,
}
impl<'a> Default for StateMachineArgs<'a> {
  #[inline]
  fn default() -> Self {
    StateMachineArgs {
      node_id: None, // required field
      name: None,
      states: None, // required field
      transitions: None, // required field
    }
  }
}

pub struct StateMachineBuilder<'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> StateMachineBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StateMachine::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StateMachine::VT_NAME, name);
  }
  #[inline]
  pub fn add_states(&mut self, states: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<State<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StateMachine::VT_STATES, states);
  }
  #[inline]
  pub fn add_transitions(&mut self, transitions: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Transition<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StateMachine::VT_TRANSITIONS, transitions);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StateMachineBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    StateMachineBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<StateMachine<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, StateMachine::VT_NODE_ID,"node_id");
    self.fbb_.required(o, StateMachine::VT_STATES,"states");
    self.fbb_.required(o, StateMachine::VT_TRANSITIONS,"transitions");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> DataSource<'a> {
  pub const VT_PROVIDER: flatbuffers::VOffsetT = 4;
  pub const VT_ENDPOINT: flatbuffers::VOffsetT = 6;
  pub const VT_RESOURCE: flatbuffers::VOffsetT = 8;
  pub const VT_METHOD: flatbuffers::VOffsetT = 10;
  pub const VT_HEADERS: flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    DataSource { _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 DataSourceArgs<'args>
  ) -> flatbuffers::WIPOffset<DataSource<'bldr>> {
    let mut builder = DataSourceBuilder::new(_fbb);
    if let Some(x) = args.headers { builder.add_headers(x); }
    if let Some(x) = args.resource { builder.add_resource(x); }
    if let Some(x) = args.endpoint { builder.add_endpoint(x); }
    builder.add_method(args.method);
    builder.add_provider(args.provider);
    builder.finish()
  }


  #[inline]
  pub fn provider(&self) -> DataSourceProvider {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<DataSourceProvider>(DataSource::VT_PROVIDER, Some(DataSourceProvider::Rest)).unwrap()}
  }
  #[inline]
  pub fn endpoint(&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>>(DataSource::VT_ENDPOINT, None)}
  }
  #[inline]
  pub fn resource(&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>>(DataSource::VT_RESOURCE, None)}
  }
  #[inline]
  pub fn method(&self) -> HttpMethod {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<HttpMethod>(DataSource::VT_METHOD, Some(HttpMethod::GET)).unwrap()}
  }
  #[inline]
  pub fn headers(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'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<KeyValue>>>>(DataSource::VT_HEADERS, None)}
  }
}

impl flatbuffers::Verifiable for DataSource<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<DataSourceProvider>("provider", Self::VT_PROVIDER, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("endpoint", Self::VT_ENDPOINT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("resource", Self::VT_RESOURCE, false)?
     .visit_field::<HttpMethod>("method", Self::VT_METHOD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>("headers", Self::VT_HEADERS, false)?
     .finish();
    Ok(())
  }
}
pub struct DataSourceArgs<'a> {
    pub provider: DataSourceProvider,
    pub endpoint: Option<flatbuffers::WIPOffset<&'a str>>,
    pub resource: Option<flatbuffers::WIPOffset<&'a str>>,
    pub method: HttpMethod,
    pub headers: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>>,
}
impl<'a> Default for DataSourceArgs<'a> {
  #[inline]
  fn default() -> Self {
    DataSourceArgs {
      provider: DataSourceProvider::Rest,
      endpoint: None,
      resource: None,
      method: HttpMethod::GET,
      headers: None,
    }
  }
}

pub struct DataSourceBuilder<'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> DataSourceBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_provider(&mut self, provider: DataSourceProvider) {
    self.fbb_.push_slot::<DataSourceProvider>(DataSource::VT_PROVIDER, provider, DataSourceProvider::Rest);
  }
  #[inline]
  pub fn add_endpoint(&mut self, endpoint: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataSource::VT_ENDPOINT, endpoint);
  }
  #[inline]
  pub fn add_resource(&mut self, resource: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataSource::VT_RESOURCE, resource);
  }
  #[inline]
  pub fn add_method(&mut self, method: HttpMethod) {
    self.fbb_.push_slot::<HttpMethod>(DataSource::VT_METHOD, method, HttpMethod::GET);
  }
  #[inline]
  pub fn add_headers(&mut self, headers: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<KeyValue<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataSource::VT_HEADERS, headers);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> DataSourceBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    DataSourceBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<DataSource<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> KeyValue<'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 {
    KeyValue { _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 KeyValueArgs<'args>
  ) -> flatbuffers::WIPOffset<KeyValue<'bldr>> {
    let mut builder = KeyValueBuilder::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>>(KeyValue::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>>(KeyValue::VT_VALUE, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for KeyValue<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    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 KeyValueArgs<'a> {
    pub key: Option<flatbuffers::WIPOffset<&'a str>>,
    pub value: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for KeyValueArgs<'a> {
  #[inline]
  fn default() -> Self {
    KeyValueArgs {
      key: None, // required field
      value: None, // required field
    }
  }
}

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

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

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

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

impl<'a> DataNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_SOURCE: flatbuffers::VOffsetT = 8;
  pub const VT_CACHE_STRATEGY: flatbuffers::VOffsetT = 10;
  pub const VT_STALE_TIME: flatbuffers::VOffsetT = 12;
  pub const VT_CACHE_TIME: flatbuffers::VOffsetT = 14;
  pub const VT_CACHE_TAGS: flatbuffers::VOffsetT = 16;
  pub const VT_AUTH_REQUIRED: flatbuffers::VOffsetT = 18;
  pub const VT_LOADING_STATE_MACHINE: flatbuffers::VOffsetT = 20;
  pub const VT_QUERY_PARAMS: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    DataNode { _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 DataNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<DataNode<'bldr>> {
    let mut builder = DataNodeBuilder::new(_fbb);
    if let Some(x) = args.query_params { builder.add_query_params(x); }
    if let Some(x) = args.loading_state_machine { builder.add_loading_state_machine(x); }
    if let Some(x) = args.cache_tags { builder.add_cache_tags(x); }
    builder.add_cache_time(args.cache_time);
    builder.add_stale_time(args.stale_time);
    if let Some(x) = args.source { builder.add_source(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_auth_required(args.auth_required);
    builder.add_cache_strategy(args.cache_strategy);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(DataNode::VT_NODE_ID, None).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>>(DataNode::VT_NAME, None)}
  }
  #[inline]
  pub fn source(&self) -> DataSource<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<DataSource>>(DataNode::VT_SOURCE, None).unwrap()}
  }
  /// Cache behavior.
  #[inline]
  pub fn cache_strategy(&self) -> CacheStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<CacheStrategy>(DataNode::VT_CACHE_STRATEGY, Some(CacheStrategy::StaleWhileRevalidate)).unwrap()}
  }
  /// How long data is considered fresh (ms).
  #[inline]
  pub fn stale_time(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(DataNode::VT_STALE_TIME, Some(30000)).unwrap()}
  }
  /// How long to keep unused data in cache (ms).
  #[inline]
  pub fn cache_time(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(DataNode::VT_CACHE_TIME, Some(300000)).unwrap()}
  }
  /// Tags for invalidation (ActionNode references these).
  #[inline]
  pub fn cache_tags(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>(DataNode::VT_CACHE_TAGS, None)}
  }
  /// Whether this data requires authentication.
  #[inline]
  pub fn auth_required(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(DataNode::VT_AUTH_REQUIRED, Some(false)).unwrap()}
  }
  /// Reference to a StateMachine that tracks loading/error/success state.
  #[inline]
  pub fn loading_state_machine(&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>>(DataNode::VT_LOADING_STATE_MACHINE, None)}
  }
  /// Query parameters — filters, sort, pagination.
  #[inline]
  pub fn query_params(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'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<KeyValue>>>>(DataNode::VT_QUERY_PARAMS, None)}
  }
}

impl flatbuffers::Verifiable for DataNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<DataSource>>("source", Self::VT_SOURCE, true)?
     .visit_field::<CacheStrategy>("cache_strategy", Self::VT_CACHE_STRATEGY, false)?
     .visit_field::<u32>("stale_time", Self::VT_STALE_TIME, false)?
     .visit_field::<u32>("cache_time", Self::VT_CACHE_TIME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("cache_tags", Self::VT_CACHE_TAGS, false)?
     .visit_field::<bool>("auth_required", Self::VT_AUTH_REQUIRED, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("loading_state_machine", Self::VT_LOADING_STATE_MACHINE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>("query_params", Self::VT_QUERY_PARAMS, false)?
     .finish();
    Ok(())
  }
}
pub struct DataNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source: Option<flatbuffers::WIPOffset<DataSource<'a>>>,
    pub cache_strategy: CacheStrategy,
    pub stale_time: u32,
    pub cache_time: u32,
    pub cache_tags: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub auth_required: bool,
    pub loading_state_machine: Option<flatbuffers::WIPOffset<&'a str>>,
    pub query_params: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>>,
}
impl<'a> Default for DataNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    DataNodeArgs {
      node_id: None, // required field
      name: None,
      source: None, // required field
      cache_strategy: CacheStrategy::StaleWhileRevalidate,
      stale_time: 30000,
      cache_time: 300000,
      cache_tags: None,
      auth_required: false,
      loading_state_machine: None,
      query_params: None,
    }
  }
}

pub struct DataNodeBuilder<'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> DataNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_source(&mut self, source: flatbuffers::WIPOffset<DataSource<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<DataSource>>(DataNode::VT_SOURCE, source);
  }
  #[inline]
  pub fn add_cache_strategy(&mut self, cache_strategy: CacheStrategy) {
    self.fbb_.push_slot::<CacheStrategy>(DataNode::VT_CACHE_STRATEGY, cache_strategy, CacheStrategy::StaleWhileRevalidate);
  }
  #[inline]
  pub fn add_stale_time(&mut self, stale_time: u32) {
    self.fbb_.push_slot::<u32>(DataNode::VT_STALE_TIME, stale_time, 30000);
  }
  #[inline]
  pub fn add_cache_time(&mut self, cache_time: u32) {
    self.fbb_.push_slot::<u32>(DataNode::VT_CACHE_TIME, cache_time, 300000);
  }
  #[inline]
  pub fn add_cache_tags(&mut self, cache_tags: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataNode::VT_CACHE_TAGS, cache_tags);
  }
  #[inline]
  pub fn add_auth_required(&mut self, auth_required: bool) {
    self.fbb_.push_slot::<bool>(DataNode::VT_AUTH_REQUIRED, auth_required, false);
  }
  #[inline]
  pub fn add_loading_state_machine(&mut self, loading_state_machine: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataNode::VT_LOADING_STATE_MACHINE, loading_state_machine);
  }
  #[inline]
  pub fn add_query_params(&mut self, query_params: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<KeyValue<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(DataNode::VT_QUERY_PARAMS, query_params);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> DataNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    DataNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<DataNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, DataNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, DataNode::VT_SOURCE,"source");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for DataNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("DataNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("source", &self.source());
      ds.field("cache_strategy", &self.cache_strategy());
      ds.field("stale_time", &self.stale_time());
      ds.field("cache_time", &self.cache_time());
      ds.field("cache_tags", &self.cache_tags());
      ds.field("auth_required", &self.auth_required());
      ds.field("loading_state_machine", &self.loading_state_machine());
      ds.field("query_params", &self.query_params());
      ds.finish()
  }
}
pub enum ComputeInputOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ComputeInput<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_SOURCE_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_FIELD_PATH: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ComputeInput { _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 ComputeInputArgs<'args>
  ) -> flatbuffers::WIPOffset<ComputeInput<'bldr>> {
    let mut builder = ComputeInputBuilder::new(_fbb);
    if let Some(x) = args.field_path { builder.add_field_path(x); }
    if let Some(x) = args.source_node_id { builder.add_source_node_id(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.finish()
  }


  #[inline]
  pub fn name(&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>>(ComputeInput::VT_NAME, None).unwrap()}
  }
  /// Source node ID (DataNode, ContextNode, or another ComputeNode).
  #[inline]
  pub fn source_node_id(&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>>(ComputeInput::VT_SOURCE_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn field_path(&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>>(ComputeInput::VT_FIELD_PATH, None)}
  }
}

impl flatbuffers::Verifiable for ComputeInput<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("source_node_id", Self::VT_SOURCE_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("field_path", Self::VT_FIELD_PATH, false)?
     .finish();
    Ok(())
  }
}
pub struct ComputeInputArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub field_path: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ComputeInputArgs<'a> {
  #[inline]
  fn default() -> Self {
    ComputeInputArgs {
      name: None, // required field
      source_node_id: None, // required field
      field_path: None,
    }
  }
}

pub struct ComputeInputBuilder<'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> ComputeInputBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeInput::VT_NAME, name);
  }
  #[inline]
  pub fn add_source_node_id(&mut self, source_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeInput::VT_SOURCE_NODE_ID, source_node_id);
  }
  #[inline]
  pub fn add_field_path(&mut self, field_path: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeInput::VT_FIELD_PATH, field_path);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ComputeInputBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ComputeInputBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ComputeInput<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ComputeInput::VT_NAME,"name");
    self.fbb_.required(o, ComputeInput::VT_SOURCE_NODE_ID,"source_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ComputeNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_INPUTS: flatbuffers::VOffsetT = 8;
  pub const VT_EXPRESSION: flatbuffers::VOffsetT = 10;
  pub const VT_OUTPUT_TYPE: flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ComputeNode { _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 ComputeNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<ComputeNode<'bldr>> {
    let mut builder = ComputeNodeBuilder::new(_fbb);
    if let Some(x) = args.output_type { builder.add_output_type(x); }
    if let Some(x) = args.expression { builder.add_expression(x); }
    if let Some(x) = args.inputs { builder.add_inputs(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ComputeNode::VT_NODE_ID, None).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>>(ComputeNode::VT_NAME, None)}
  }
  #[inline]
  pub fn inputs(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ComputeInput<'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<ComputeInput>>>>(ComputeNode::VT_INPUTS, None).unwrap()}
  }
  /// Expression to evaluate. Simple expressions only — complex logic
  /// belongs in ActionNode/EffectNode. Examples:
  /// "price * quantity", "items.length > 0", "firstName + ' ' + lastName"
  #[inline]
  pub fn expression(&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>>(ComputeNode::VT_EXPRESSION, None).unwrap()}
  }
  /// Output type hint for the compiler.
  #[inline]
  pub fn output_type(&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>>(ComputeNode::VT_OUTPUT_TYPE, None)}
  }
}

impl flatbuffers::Verifiable for ComputeNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ComputeInput>>>>("inputs", Self::VT_INPUTS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("expression", Self::VT_EXPRESSION, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("output_type", Self::VT_OUTPUT_TYPE, false)?
     .finish();
    Ok(())
  }
}
pub struct ComputeNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub inputs: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ComputeInput<'a>>>>>,
    pub expression: Option<flatbuffers::WIPOffset<&'a str>>,
    pub output_type: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ComputeNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    ComputeNodeArgs {
      node_id: None, // required field
      name: None,
      inputs: None, // required field
      expression: None, // required field
      output_type: None,
    }
  }
}

pub struct ComputeNodeBuilder<'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> ComputeNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_inputs(&mut self, inputs: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ComputeInput<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeNode::VT_INPUTS, inputs);
  }
  #[inline]
  pub fn add_expression(&mut self, expression: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeNode::VT_EXPRESSION, expression);
  }
  #[inline]
  pub fn add_output_type(&mut self, output_type: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ComputeNode::VT_OUTPUT_TYPE, output_type);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ComputeNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ComputeNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ComputeNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ComputeNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ComputeNode::VT_INPUTS,"inputs");
    self.fbb_.required(o, ComputeNode::VT_EXPRESSION,"expression");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> EffectNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_EFFECT_TYPE: flatbuffers::VOffsetT = 8;
  pub const VT_CONFIG: flatbuffers::VOffsetT = 10;
  pub const VT_API_SOURCE: flatbuffers::VOffsetT = 12;
  pub const VT_IDEMPOTENT: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    EffectNode { _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 EffectNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<EffectNode<'bldr>> {
    let mut builder = EffectNodeBuilder::new(_fbb);
    if let Some(x) = args.api_source { builder.add_api_source(x); }
    if let Some(x) = args.config { builder.add_config(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_idempotent(args.idempotent);
    builder.add_effect_type(args.effect_type);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(EffectNode::VT_NODE_ID, None).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>>(EffectNode::VT_NAME, None)}
  }
  #[inline]
  pub fn effect_type(&self) -> EffectType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<EffectType>(EffectNode::VT_EFFECT_TYPE, Some(EffectType::Analytics)).unwrap()}
  }
  /// Configuration payload (JSON-like key-value pairs).
  #[inline]
  pub fn config(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'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<KeyValue>>>>(EffectNode::VT_CONFIG, None)}
  }
  /// For ApiCall effects — the endpoint and method.
  #[inline]
  pub fn api_source(&self) -> Option<DataSource<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<DataSource>>(EffectNode::VT_API_SOURCE, None)}
  }
  /// Whether this effect is idempotent (safe to retry).
  #[inline]
  pub fn idempotent(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(EffectNode::VT_IDEMPOTENT, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for EffectNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<EffectType>("effect_type", Self::VT_EFFECT_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>("config", Self::VT_CONFIG, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<DataSource>>("api_source", Self::VT_API_SOURCE, false)?
     .visit_field::<bool>("idempotent", Self::VT_IDEMPOTENT, false)?
     .finish();
    Ok(())
  }
}
pub struct EffectNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub effect_type: EffectType,
    pub config: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>>,
    pub api_source: Option<flatbuffers::WIPOffset<DataSource<'a>>>,
    pub idempotent: bool,
}
impl<'a> Default for EffectNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    EffectNodeArgs {
      node_id: None, // required field
      name: None,
      effect_type: EffectType::Analytics,
      config: None,
      api_source: None,
      idempotent: false,
    }
  }
}

pub struct EffectNodeBuilder<'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> EffectNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(EffectNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(EffectNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_effect_type(&mut self, effect_type: EffectType) {
    self.fbb_.push_slot::<EffectType>(EffectNode::VT_EFFECT_TYPE, effect_type, EffectType::Analytics);
  }
  #[inline]
  pub fn add_config(&mut self, config: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<KeyValue<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(EffectNode::VT_CONFIG, config);
  }
  #[inline]
  pub fn add_api_source(&mut self, api_source: flatbuffers::WIPOffset<DataSource<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<DataSource>>(EffectNode::VT_API_SOURCE, api_source);
  }
  #[inline]
  pub fn add_idempotent(&mut self, idempotent: bool) {
    self.fbb_.push_slot::<bool>(EffectNode::VT_IDEMPOTENT, idempotent, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> EffectNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    EffectNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<EffectNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, EffectNode::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for EffectNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("EffectNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("effect_type", &self.effect_type());
      ds.field("config", &self.config());
      ds.field("api_source", &self.api_source());
      ds.field("idempotent", &self.idempotent());
      ds.finish()
  }
}
pub enum ContextNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ContextNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_INITIAL_VALUE: flatbuffers::VOffsetT = 8;
  pub const VT_WRITERS: flatbuffers::VOffsetT = 10;
  pub const VT_GLOBAL: flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ContextNode { _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 ContextNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<ContextNode<'bldr>> {
    let mut builder = ContextNodeBuilder::new(_fbb);
    if let Some(x) = args.writers { builder.add_writers(x); }
    if let Some(x) = args.initial_value { builder.add_initial_value(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_global(args.global);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ContextNode::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn name(&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>>(ContextNode::VT_NAME, None).unwrap()}
  }
  /// Initial value as a JSON string (parsed by the compiler).
  #[inline]
  pub fn initial_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>>(ContextNode::VT_INITIAL_VALUE, None)}
  }
  /// Node IDs that can write to this context (empty = any descendant can write).
  #[inline]
  pub fn writers(&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>>>>(ContextNode::VT_WRITERS, None)}
  }
  /// If true, this context is globally accessible (not scoped to subtree).
  #[inline]
  pub fn global(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ContextNode::VT_GLOBAL, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for ContextNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("initial_value", Self::VT_INITIAL_VALUE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("writers", Self::VT_WRITERS, false)?
     .visit_field::<bool>("global", Self::VT_GLOBAL, false)?
     .finish();
    Ok(())
  }
}
pub struct ContextNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub initial_value: Option<flatbuffers::WIPOffset<&'a str>>,
    pub writers: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub global: bool,
}
impl<'a> Default for ContextNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    ContextNodeArgs {
      node_id: None, // required field
      name: None, // required field
      initial_value: None,
      writers: None,
      global: false,
    }
  }
}

pub struct ContextNodeBuilder<'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> ContextNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContextNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContextNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_initial_value(&mut self, initial_value: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContextNode::VT_INITIAL_VALUE, initial_value);
  }
  #[inline]
  pub fn add_writers(&mut self, writers: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContextNode::VT_WRITERS, writers);
  }
  #[inline]
  pub fn add_global(&mut self, global: bool) {
    self.fbb_.push_slot::<bool>(ContextNode::VT_GLOBAL, global, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ContextNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ContextNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ContextNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ContextNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ContextNode::VT_NAME,"name");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SemanticNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_ROLE: flatbuffers::VOffsetT = 6;
  pub const VT_LABEL: flatbuffers::VOffsetT = 8;
  pub const VT_LABELLED_BY: flatbuffers::VOffsetT = 10;
  pub const VT_DESCRIBED_BY: flatbuffers::VOffsetT = 12;
  pub const VT_CONTROLS: flatbuffers::VOffsetT = 14;
  pub const VT_OWNED_BY: flatbuffers::VOffsetT = 16;
  pub const VT_HEADING_LEVEL: flatbuffers::VOffsetT = 18;
  pub const VT_TAB_INDEX: flatbuffers::VOffsetT = 20;
  pub const VT_HIDDEN: flatbuffers::VOffsetT = 22;
  pub const VT_ARIA_EXPANDED: flatbuffers::VOffsetT = 24;
  pub const VT_ARIA_SELECTED: flatbuffers::VOffsetT = 26;
  pub const VT_ARIA_CHECKED: flatbuffers::VOffsetT = 28;
  pub const VT_ARIA_DISABLED: flatbuffers::VOffsetT = 30;
  pub const VT_ARIA_REQUIRED: flatbuffers::VOffsetT = 32;
  pub const VT_ARIA_INVALID: flatbuffers::VOffsetT = 34;
  pub const VT_ARIA_VALUE_MIN: flatbuffers::VOffsetT = 36;
  pub const VT_ARIA_VALUE_MAX: flatbuffers::VOffsetT = 38;
  pub const VT_ARIA_VALUE_NOW: flatbuffers::VOffsetT = 40;
  pub const VT_ARIA_VALUE_TEXT: flatbuffers::VOffsetT = 42;
  pub const VT_CUSTOM_ARIA: flatbuffers::VOffsetT = 44;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SemanticNode { _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 SemanticNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<SemanticNode<'bldr>> {
    let mut builder = SemanticNodeBuilder::new(_fbb);
    if let Some(x) = args.custom_aria { builder.add_custom_aria(x); }
    if let Some(x) = args.aria_value_text { builder.add_aria_value_text(x); }
    builder.add_aria_value_now(args.aria_value_now);
    builder.add_aria_value_max(args.aria_value_max);
    builder.add_aria_value_min(args.aria_value_min);
    builder.add_tab_index(args.tab_index);
    if let Some(x) = args.owned_by { builder.add_owned_by(x); }
    if let Some(x) = args.controls { builder.add_controls(x); }
    if let Some(x) = args.described_by { builder.add_described_by(x); }
    if let Some(x) = args.labelled_by { builder.add_labelled_by(x); }
    if let Some(x) = args.label { builder.add_label(x); }
    if let Some(x) = args.role { builder.add_role(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_aria_invalid(args.aria_invalid);
    builder.add_aria_required(args.aria_required);
    builder.add_aria_disabled(args.aria_disabled);
    builder.add_aria_checked(args.aria_checked);
    builder.add_aria_selected(args.aria_selected);
    builder.add_aria_expanded(args.aria_expanded);
    builder.add_hidden(args.hidden);
    builder.add_heading_level(args.heading_level);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(SemanticNode::VT_NODE_ID, None).unwrap()}
  }
  /// ARIA role (e.g., "button", "heading", "navigation", "main").
  /// Validated against WAI-ARIA 1.2 role list by the validator.
  #[inline]
  pub fn role(&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>>(SemanticNode::VT_ROLE, None).unwrap()}
  }
  /// Human-readable accessible label.
  /// For buttons/links: the text announced by screen readers.
  /// For images: the alt text equivalent.
  /// For headings: usually matches the visible text.
  #[inline]
  pub fn 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>>(SemanticNode::VT_LABEL, None)}
  }
  /// Reference to another node whose content labels this node (aria-labelledby).
  #[inline]
  pub fn labelled_by(&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>>(SemanticNode::VT_LABELLED_BY, None)}
  }
  /// Reference to a node providing extended description (aria-describedby).
  #[inline]
  pub fn described_by(&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>>(SemanticNode::VT_DESCRIBED_BY, None)}
  }
  /// Reference to a node this element controls (aria-controls).
  #[inline]
  pub fn controls(&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>>(SemanticNode::VT_CONTROLS, None)}
  }
  /// Reference to a node that owns this element (aria-owns).
  #[inline]
  pub fn owned_by(&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>>(SemanticNode::VT_OWNED_BY, None)}
  }
  /// Heading level (1-6). Only valid when role = "heading".
  #[inline]
  pub fn heading_level(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(SemanticNode::VT_HEADING_LEVEL, Some(0)).unwrap()}
  }
  /// Tab index for keyboard focus order.
  /// -1 = focusable but not in tab order (programmatic focus only).
  /// 0 = focusable in natural tab order.
  /// >0 = explicit order (discouraged but supported).
  #[inline]
  pub fn tab_index(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(SemanticNode::VT_TAB_INDEX, Some(-2)).unwrap()}
  }
  /// Whether this element is currently hidden from the a11y tree.
  #[inline]
  pub fn hidden(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SemanticNode::VT_HIDDEN, Some(false)).unwrap()}
  }
  /// ARIA states (set dynamically by state machines).
  #[inline]
  pub fn aria_expanded(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(SemanticNode::VT_ARIA_EXPANDED, Some(-1)).unwrap()}
  }
  #[inline]
  pub fn aria_selected(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(SemanticNode::VT_ARIA_SELECTED, Some(-1)).unwrap()}
  }
  #[inline]
  pub fn aria_checked(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(SemanticNode::VT_ARIA_CHECKED, Some(-1)).unwrap()}
  }
  #[inline]
  pub fn aria_disabled(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SemanticNode::VT_ARIA_DISABLED, Some(false)).unwrap()}
  }
  #[inline]
  pub fn aria_required(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SemanticNode::VT_ARIA_REQUIRED, Some(false)).unwrap()}
  }
  #[inline]
  pub fn aria_invalid(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SemanticNode::VT_ARIA_INVALID, Some(false)).unwrap()}
  }
  /// For range widgets (slider, progressbar, spinbutton).
  #[inline]
  pub fn aria_value_min(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(SemanticNode::VT_ARIA_VALUE_MIN, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn aria_value_max(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(SemanticNode::VT_ARIA_VALUE_MAX, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn aria_value_now(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(SemanticNode::VT_ARIA_VALUE_NOW, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn aria_value_text(&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>>(SemanticNode::VT_ARIA_VALUE_TEXT, None)}
  }
  /// Custom ARIA attributes (escape hatch for uncommon attributes).
  #[inline]
  pub fn custom_aria(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'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<KeyValue>>>>(SemanticNode::VT_CUSTOM_ARIA, None)}
  }
}

impl flatbuffers::Verifiable for SemanticNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("role", Self::VT_ROLE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("label", Self::VT_LABEL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("labelled_by", Self::VT_LABELLED_BY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("described_by", Self::VT_DESCRIBED_BY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("controls", Self::VT_CONTROLS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("owned_by", Self::VT_OWNED_BY, false)?
     .visit_field::<i8>("heading_level", Self::VT_HEADING_LEVEL, false)?
     .visit_field::<i32>("tab_index", Self::VT_TAB_INDEX, false)?
     .visit_field::<bool>("hidden", Self::VT_HIDDEN, false)?
     .visit_field::<i8>("aria_expanded", Self::VT_ARIA_EXPANDED, false)?
     .visit_field::<i8>("aria_selected", Self::VT_ARIA_SELECTED, false)?
     .visit_field::<i8>("aria_checked", Self::VT_ARIA_CHECKED, false)?
     .visit_field::<bool>("aria_disabled", Self::VT_ARIA_DISABLED, false)?
     .visit_field::<bool>("aria_required", Self::VT_ARIA_REQUIRED, false)?
     .visit_field::<bool>("aria_invalid", Self::VT_ARIA_INVALID, false)?
     .visit_field::<f32>("aria_value_min", Self::VT_ARIA_VALUE_MIN, false)?
     .visit_field::<f32>("aria_value_max", Self::VT_ARIA_VALUE_MAX, false)?
     .visit_field::<f32>("aria_value_now", Self::VT_ARIA_VALUE_NOW, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("aria_value_text", Self::VT_ARIA_VALUE_TEXT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>("custom_aria", Self::VT_CUSTOM_ARIA, false)?
     .finish();
    Ok(())
  }
}
pub struct SemanticNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub role: Option<flatbuffers::WIPOffset<&'a str>>,
    pub label: Option<flatbuffers::WIPOffset<&'a str>>,
    pub labelled_by: Option<flatbuffers::WIPOffset<&'a str>>,
    pub described_by: Option<flatbuffers::WIPOffset<&'a str>>,
    pub controls: Option<flatbuffers::WIPOffset<&'a str>>,
    pub owned_by: Option<flatbuffers::WIPOffset<&'a str>>,
    pub heading_level: i8,
    pub tab_index: i32,
    pub hidden: bool,
    pub aria_expanded: i8,
    pub aria_selected: i8,
    pub aria_checked: i8,
    pub aria_disabled: bool,
    pub aria_required: bool,
    pub aria_invalid: bool,
    pub aria_value_min: f32,
    pub aria_value_max: f32,
    pub aria_value_now: f32,
    pub aria_value_text: Option<flatbuffers::WIPOffset<&'a str>>,
    pub custom_aria: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>>,
}
impl<'a> Default for SemanticNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    SemanticNodeArgs {
      node_id: None, // required field
      role: None, // required field
      label: None,
      labelled_by: None,
      described_by: None,
      controls: None,
      owned_by: None,
      heading_level: 0,
      tab_index: -2,
      hidden: false,
      aria_expanded: -1,
      aria_selected: -1,
      aria_checked: -1,
      aria_disabled: false,
      aria_required: false,
      aria_invalid: false,
      aria_value_min: 0.0,
      aria_value_max: 0.0,
      aria_value_now: 0.0,
      aria_value_text: None,
      custom_aria: None,
    }
  }
}

pub struct SemanticNodeBuilder<'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> SemanticNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_role(&mut self, role: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_ROLE, role);
  }
  #[inline]
  pub fn add_label(&mut self, label: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_LABEL, label);
  }
  #[inline]
  pub fn add_labelled_by(&mut self, labelled_by: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_LABELLED_BY, labelled_by);
  }
  #[inline]
  pub fn add_described_by(&mut self, described_by: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_DESCRIBED_BY, described_by);
  }
  #[inline]
  pub fn add_controls(&mut self, controls: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_CONTROLS, controls);
  }
  #[inline]
  pub fn add_owned_by(&mut self, owned_by: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_OWNED_BY, owned_by);
  }
  #[inline]
  pub fn add_heading_level(&mut self, heading_level: i8) {
    self.fbb_.push_slot::<i8>(SemanticNode::VT_HEADING_LEVEL, heading_level, 0);
  }
  #[inline]
  pub fn add_tab_index(&mut self, tab_index: i32) {
    self.fbb_.push_slot::<i32>(SemanticNode::VT_TAB_INDEX, tab_index, -2);
  }
  #[inline]
  pub fn add_hidden(&mut self, hidden: bool) {
    self.fbb_.push_slot::<bool>(SemanticNode::VT_HIDDEN, hidden, false);
  }
  #[inline]
  pub fn add_aria_expanded(&mut self, aria_expanded: i8) {
    self.fbb_.push_slot::<i8>(SemanticNode::VT_ARIA_EXPANDED, aria_expanded, -1);
  }
  #[inline]
  pub fn add_aria_selected(&mut self, aria_selected: i8) {
    self.fbb_.push_slot::<i8>(SemanticNode::VT_ARIA_SELECTED, aria_selected, -1);
  }
  #[inline]
  pub fn add_aria_checked(&mut self, aria_checked: i8) {
    self.fbb_.push_slot::<i8>(SemanticNode::VT_ARIA_CHECKED, aria_checked, -1);
  }
  #[inline]
  pub fn add_aria_disabled(&mut self, aria_disabled: bool) {
    self.fbb_.push_slot::<bool>(SemanticNode::VT_ARIA_DISABLED, aria_disabled, false);
  }
  #[inline]
  pub fn add_aria_required(&mut self, aria_required: bool) {
    self.fbb_.push_slot::<bool>(SemanticNode::VT_ARIA_REQUIRED, aria_required, false);
  }
  #[inline]
  pub fn add_aria_invalid(&mut self, aria_invalid: bool) {
    self.fbb_.push_slot::<bool>(SemanticNode::VT_ARIA_INVALID, aria_invalid, false);
  }
  #[inline]
  pub fn add_aria_value_min(&mut self, aria_value_min: f32) {
    self.fbb_.push_slot::<f32>(SemanticNode::VT_ARIA_VALUE_MIN, aria_value_min, 0.0);
  }
  #[inline]
  pub fn add_aria_value_max(&mut self, aria_value_max: f32) {
    self.fbb_.push_slot::<f32>(SemanticNode::VT_ARIA_VALUE_MAX, aria_value_max, 0.0);
  }
  #[inline]
  pub fn add_aria_value_now(&mut self, aria_value_now: f32) {
    self.fbb_.push_slot::<f32>(SemanticNode::VT_ARIA_VALUE_NOW, aria_value_now, 0.0);
  }
  #[inline]
  pub fn add_aria_value_text(&mut self, aria_value_text: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_ARIA_VALUE_TEXT, aria_value_text);
  }
  #[inline]
  pub fn add_custom_aria(&mut self, custom_aria: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<KeyValue<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SemanticNode::VT_CUSTOM_ARIA, custom_aria);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SemanticNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SemanticNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SemanticNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SemanticNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, SemanticNode::VT_ROLE,"role");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for SemanticNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("SemanticNode");
      ds.field("node_id", &self.node_id());
      ds.field("role", &self.role());
      ds.field("label", &self.label());
      ds.field("labelled_by", &self.labelled_by());
      ds.field("described_by", &self.described_by());
      ds.field("controls", &self.controls());
      ds.field("owned_by", &self.owned_by());
      ds.field("heading_level", &self.heading_level());
      ds.field("tab_index", &self.tab_index());
      ds.field("hidden", &self.hidden());
      ds.field("aria_expanded", &self.aria_expanded());
      ds.field("aria_selected", &self.aria_selected());
      ds.field("aria_checked", &self.aria_checked());
      ds.field("aria_disabled", &self.aria_disabled());
      ds.field("aria_required", &self.aria_required());
      ds.field("aria_invalid", &self.aria_invalid());
      ds.field("aria_value_min", &self.aria_value_min());
      ds.field("aria_value_max", &self.aria_value_max());
      ds.field("aria_value_now", &self.aria_value_now());
      ds.field("aria_value_text", &self.aria_value_text());
      ds.field("custom_aria", &self.custom_aria());
      ds.finish()
  }
}
pub enum LiveRegionOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> LiveRegion<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_POLITENESS: flatbuffers::VOffsetT = 8;
  pub const VT_ATOMIC: flatbuffers::VOffsetT = 10;
  pub const VT_RELEVANT: flatbuffers::VOffsetT = 12;
  pub const VT_ROLE_DESCRIPTION: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    LiveRegion { _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 LiveRegionArgs<'args>
  ) -> flatbuffers::WIPOffset<LiveRegion<'bldr>> {
    let mut builder = LiveRegionBuilder::new(_fbb);
    if let Some(x) = args.role_description { builder.add_role_description(x); }
    if let Some(x) = args.target_node_id { builder.add_target_node_id(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_relevant(args.relevant);
    builder.add_atomic(args.atomic);
    builder.add_politeness(args.politeness);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(LiveRegion::VT_NODE_ID, None).unwrap()}
  }
  /// Which visual node this live region is attached to.
  #[inline]
  pub fn target_node_id(&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>>(LiveRegion::VT_TARGET_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn politeness(&self) -> LiveRegionPoliteness {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<LiveRegionPoliteness>(LiveRegion::VT_POLITENESS, Some(LiveRegionPoliteness::Polite)).unwrap()}
  }
  /// If true, announce the entire region on change (not just the diff).
  #[inline]
  pub fn atomic(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(LiveRegion::VT_ATOMIC, Some(false)).unwrap()}
  }
  #[inline]
  pub fn relevant(&self) -> LiveRegionRelevant {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<LiveRegionRelevant>(LiveRegion::VT_RELEVANT, Some(LiveRegionRelevant::Additions)).unwrap()}
  }
  /// Human-readable role description (e.g., "Shopping cart updates").
  #[inline]
  pub fn role_description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(LiveRegion::VT_ROLE_DESCRIPTION, None)}
  }
}

impl flatbuffers::Verifiable for LiveRegion<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<LiveRegionPoliteness>("politeness", Self::VT_POLITENESS, false)?
     .visit_field::<bool>("atomic", Self::VT_ATOMIC, false)?
     .visit_field::<LiveRegionRelevant>("relevant", Self::VT_RELEVANT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("role_description", Self::VT_ROLE_DESCRIPTION, false)?
     .finish();
    Ok(())
  }
}
pub struct LiveRegionArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub politeness: LiveRegionPoliteness,
    pub atomic: bool,
    pub relevant: LiveRegionRelevant,
    pub role_description: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for LiveRegionArgs<'a> {
  #[inline]
  fn default() -> Self {
    LiveRegionArgs {
      node_id: None, // required field
      target_node_id: None, // required field
      politeness: LiveRegionPoliteness::Polite,
      atomic: false,
      relevant: LiveRegionRelevant::Additions,
      role_description: None,
    }
  }
}

pub struct LiveRegionBuilder<'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> LiveRegionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LiveRegion::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_target_node_id(&mut self, target_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LiveRegion::VT_TARGET_NODE_ID, target_node_id);
  }
  #[inline]
  pub fn add_politeness(&mut self, politeness: LiveRegionPoliteness) {
    self.fbb_.push_slot::<LiveRegionPoliteness>(LiveRegion::VT_POLITENESS, politeness, LiveRegionPoliteness::Polite);
  }
  #[inline]
  pub fn add_atomic(&mut self, atomic: bool) {
    self.fbb_.push_slot::<bool>(LiveRegion::VT_ATOMIC, atomic, false);
  }
  #[inline]
  pub fn add_relevant(&mut self, relevant: LiveRegionRelevant) {
    self.fbb_.push_slot::<LiveRegionRelevant>(LiveRegion::VT_RELEVANT, relevant, LiveRegionRelevant::Additions);
  }
  #[inline]
  pub fn add_role_description(&mut self, role_description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LiveRegion::VT_ROLE_DESCRIPTION, role_description);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> LiveRegionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    LiveRegionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<LiveRegion<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, LiveRegion::VT_NODE_ID,"node_id");
    self.fbb_.required(o, LiveRegion::VT_TARGET_NODE_ID,"target_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for LiveRegion<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("LiveRegion");
      ds.field("node_id", &self.node_id());
      ds.field("target_node_id", &self.target_node_id());
      ds.field("politeness", &self.politeness());
      ds.field("atomic", &self.atomic());
      ds.field("relevant", &self.relevant());
      ds.field("role_description", &self.role_description());
      ds.finish()
  }
}
pub enum FocusTrapOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> FocusTrap<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CONTAINER_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_INITIAL_FOCUS_NODE_ID: flatbuffers::VOffsetT = 8;
  pub const VT_ESCAPE_BEHAVIOR: flatbuffers::VOffsetT = 10;
  pub const VT_ESCAPE_STATE_MACHINE: flatbuffers::VOffsetT = 12;
  pub const VT_ESCAPE_EVENT: flatbuffers::VOffsetT = 14;
  pub const VT_RESTORE_FOCUS: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FocusTrap { _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 FocusTrapArgs<'args>
  ) -> flatbuffers::WIPOffset<FocusTrap<'bldr>> {
    let mut builder = FocusTrapBuilder::new(_fbb);
    if let Some(x) = args.escape_event { builder.add_escape_event(x); }
    if let Some(x) = args.escape_state_machine { builder.add_escape_state_machine(x); }
    if let Some(x) = args.initial_focus_node_id { builder.add_initial_focus_node_id(x); }
    if let Some(x) = args.container_node_id { builder.add_container_node_id(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_restore_focus(args.restore_focus);
    builder.add_escape_behavior(args.escape_behavior);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(FocusTrap::VT_NODE_ID, None).unwrap()}
  }
  /// The container node whose subtree receives trapped focus.
  #[inline]
  pub fn container_node_id(&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>>(FocusTrap::VT_CONTAINER_NODE_ID, None).unwrap()}
  }
  /// Node to focus when the trap activates. If not set, focuses
  /// the first focusable element in the container.
  #[inline]
  pub fn initial_focus_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FocusTrap::VT_INITIAL_FOCUS_NODE_ID, None)}
  }
  /// What happens when Escape is pressed.
  #[inline]
  pub fn escape_behavior(&self) -> FocusTrapEscape {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<FocusTrapEscape>(FocusTrap::VT_ESCAPE_BEHAVIOR, Some(FocusTrapEscape::CloseOnEscape)).unwrap()}
  }
  /// For FireEvent escape: which state machine and event to fire.
  #[inline]
  pub fn escape_state_machine(&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>>(FocusTrap::VT_ESCAPE_STATE_MACHINE, None)}
  }
  #[inline]
  pub fn escape_event(&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>>(FocusTrap::VT_ESCAPE_EVENT, None)}
  }
  /// Whether to restore focus to the previously focused element
  /// when the trap deactivates.
  #[inline]
  pub fn restore_focus(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(FocusTrap::VT_RESTORE_FOCUS, Some(true)).unwrap()}
  }
}

impl flatbuffers::Verifiable for FocusTrap<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("container_node_id", Self::VT_CONTAINER_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("initial_focus_node_id", Self::VT_INITIAL_FOCUS_NODE_ID, false)?
     .visit_field::<FocusTrapEscape>("escape_behavior", Self::VT_ESCAPE_BEHAVIOR, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("escape_state_machine", Self::VT_ESCAPE_STATE_MACHINE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("escape_event", Self::VT_ESCAPE_EVENT, false)?
     .visit_field::<bool>("restore_focus", Self::VT_RESTORE_FOCUS, false)?
     .finish();
    Ok(())
  }
}
pub struct FocusTrapArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub container_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub initial_focus_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub escape_behavior: FocusTrapEscape,
    pub escape_state_machine: Option<flatbuffers::WIPOffset<&'a str>>,
    pub escape_event: Option<flatbuffers::WIPOffset<&'a str>>,
    pub restore_focus: bool,
}
impl<'a> Default for FocusTrapArgs<'a> {
  #[inline]
  fn default() -> Self {
    FocusTrapArgs {
      node_id: None, // required field
      container_node_id: None, // required field
      initial_focus_node_id: None,
      escape_behavior: FocusTrapEscape::CloseOnEscape,
      escape_state_machine: None,
      escape_event: None,
      restore_focus: true,
    }
  }
}

pub struct FocusTrapBuilder<'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> FocusTrapBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FocusTrap::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_container_node_id(&mut self, container_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FocusTrap::VT_CONTAINER_NODE_ID, container_node_id);
  }
  #[inline]
  pub fn add_initial_focus_node_id(&mut self, initial_focus_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FocusTrap::VT_INITIAL_FOCUS_NODE_ID, initial_focus_node_id);
  }
  #[inline]
  pub fn add_escape_behavior(&mut self, escape_behavior: FocusTrapEscape) {
    self.fbb_.push_slot::<FocusTrapEscape>(FocusTrap::VT_ESCAPE_BEHAVIOR, escape_behavior, FocusTrapEscape::CloseOnEscape);
  }
  #[inline]
  pub fn add_escape_state_machine(&mut self, escape_state_machine: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FocusTrap::VT_ESCAPE_STATE_MACHINE, escape_state_machine);
  }
  #[inline]
  pub fn add_escape_event(&mut self, escape_event: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FocusTrap::VT_ESCAPE_EVENT, escape_event);
  }
  #[inline]
  pub fn add_restore_focus(&mut self, restore_focus: bool) {
    self.fbb_.push_slot::<bool>(FocusTrap::VT_RESTORE_FOCUS, restore_focus, true);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FocusTrapBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FocusTrapBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FocusTrap<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FocusTrap::VT_NODE_ID,"node_id");
    self.fbb_.required(o, FocusTrap::VT_CONTAINER_NODE_ID,"container_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FocusTrap<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FocusTrap");
      ds.field("node_id", &self.node_id());
      ds.field("container_node_id", &self.container_node_id());
      ds.field("initial_focus_node_id", &self.initial_focus_node_id());
      ds.field("escape_behavior", &self.escape_behavior());
      ds.field("escape_state_machine", &self.escape_state_machine());
      ds.field("escape_event", &self.escape_event());
      ds.field("restore_focus", &self.restore_focus());
      ds.finish()
  }
}
pub enum ColorPaletteOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ColorPalette<'a> {
  pub const VT_PRIMARY: flatbuffers::VOffsetT = 4;
  pub const VT_PRIMARY_FOREGROUND: flatbuffers::VOffsetT = 6;
  pub const VT_SECONDARY: flatbuffers::VOffsetT = 8;
  pub const VT_SECONDARY_FOREGROUND: flatbuffers::VOffsetT = 10;
  pub const VT_ACCENT: flatbuffers::VOffsetT = 12;
  pub const VT_ACCENT_FOREGROUND: flatbuffers::VOffsetT = 14;
  pub const VT_BACKGROUND: flatbuffers::VOffsetT = 16;
  pub const VT_FOREGROUND: flatbuffers::VOffsetT = 18;
  pub const VT_SURFACE: flatbuffers::VOffsetT = 20;
  pub const VT_SURFACE_FOREGROUND: flatbuffers::VOffsetT = 22;
  pub const VT_MUTED: flatbuffers::VOffsetT = 24;
  pub const VT_MUTED_FOREGROUND: flatbuffers::VOffsetT = 26;
  pub const VT_BORDER_COLOR: flatbuffers::VOffsetT = 28;
  pub const VT_ERROR: flatbuffers::VOffsetT = 30;
  pub const VT_ERROR_FOREGROUND: flatbuffers::VOffsetT = 32;
  pub const VT_SUCCESS: flatbuffers::VOffsetT = 34;
  pub const VT_SUCCESS_FOREGROUND: flatbuffers::VOffsetT = 36;
  pub const VT_WARNING: flatbuffers::VOffsetT = 38;
  pub const VT_WARNING_FOREGROUND: flatbuffers::VOffsetT = 40;
  pub const VT_INFO: flatbuffers::VOffsetT = 42;
  pub const VT_INFO_FOREGROUND: flatbuffers::VOffsetT = 44;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ColorPalette { _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 ColorPaletteArgs<'args>
  ) -> flatbuffers::WIPOffset<ColorPalette<'bldr>> {
    let mut builder = ColorPaletteBuilder::new(_fbb);
    if let Some(x) = args.info_foreground { builder.add_info_foreground(x); }
    if let Some(x) = args.info { builder.add_info(x); }
    if let Some(x) = args.warning_foreground { builder.add_warning_foreground(x); }
    if let Some(x) = args.warning { builder.add_warning(x); }
    if let Some(x) = args.success_foreground { builder.add_success_foreground(x); }
    if let Some(x) = args.success { builder.add_success(x); }
    if let Some(x) = args.error_foreground { builder.add_error_foreground(x); }
    if let Some(x) = args.error { builder.add_error(x); }
    if let Some(x) = args.border_color { builder.add_border_color(x); }
    if let Some(x) = args.muted_foreground { builder.add_muted_foreground(x); }
    if let Some(x) = args.muted { builder.add_muted(x); }
    if let Some(x) = args.surface_foreground { builder.add_surface_foreground(x); }
    if let Some(x) = args.surface { builder.add_surface(x); }
    if let Some(x) = args.foreground { builder.add_foreground(x); }
    if let Some(x) = args.background { builder.add_background(x); }
    if let Some(x) = args.accent_foreground { builder.add_accent_foreground(x); }
    if let Some(x) = args.accent { builder.add_accent(x); }
    if let Some(x) = args.secondary_foreground { builder.add_secondary_foreground(x); }
    if let Some(x) = args.secondary { builder.add_secondary(x); }
    if let Some(x) = args.primary_foreground { builder.add_primary_foreground(x); }
    if let Some(x) = args.primary { builder.add_primary(x); }
    builder.finish()
  }


  #[inline]
  pub fn primary(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_PRIMARY, None)}
  }
  #[inline]
  pub fn primary_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_PRIMARY_FOREGROUND, None)}
  }
  #[inline]
  pub fn secondary(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SECONDARY, None)}
  }
  #[inline]
  pub fn secondary_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SECONDARY_FOREGROUND, None)}
  }
  #[inline]
  pub fn accent(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_ACCENT, None)}
  }
  #[inline]
  pub fn accent_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_ACCENT_FOREGROUND, None)}
  }
  #[inline]
  pub fn background(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_BACKGROUND, None)}
  }
  #[inline]
  pub fn foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_FOREGROUND, None)}
  }
  #[inline]
  pub fn surface(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SURFACE, None)}
  }
  #[inline]
  pub fn surface_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SURFACE_FOREGROUND, None)}
  }
  #[inline]
  pub fn muted(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_MUTED, None)}
  }
  #[inline]
  pub fn muted_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_MUTED_FOREGROUND, None)}
  }
  #[inline]
  pub fn border_color(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_BORDER_COLOR, None)}
  }
  #[inline]
  pub fn error(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_ERROR, None)}
  }
  #[inline]
  pub fn error_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_ERROR_FOREGROUND, None)}
  }
  #[inline]
  pub fn success(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SUCCESS, None)}
  }
  #[inline]
  pub fn success_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_SUCCESS_FOREGROUND, None)}
  }
  #[inline]
  pub fn warning(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_WARNING, None)}
  }
  #[inline]
  pub fn warning_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_WARNING_FOREGROUND, None)}
  }
  #[inline]
  pub fn info(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_INFO, None)}
  }
  #[inline]
  pub fn info_foreground(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ColorPalette::VT_INFO_FOREGROUND, None)}
  }
}

impl flatbuffers::Verifiable for ColorPalette<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<Color>("primary", Self::VT_PRIMARY, false)?
     .visit_field::<Color>("primary_foreground", Self::VT_PRIMARY_FOREGROUND, false)?
     .visit_field::<Color>("secondary", Self::VT_SECONDARY, false)?
     .visit_field::<Color>("secondary_foreground", Self::VT_SECONDARY_FOREGROUND, false)?
     .visit_field::<Color>("accent", Self::VT_ACCENT, false)?
     .visit_field::<Color>("accent_foreground", Self::VT_ACCENT_FOREGROUND, false)?
     .visit_field::<Color>("background", Self::VT_BACKGROUND, false)?
     .visit_field::<Color>("foreground", Self::VT_FOREGROUND, false)?
     .visit_field::<Color>("surface", Self::VT_SURFACE, false)?
     .visit_field::<Color>("surface_foreground", Self::VT_SURFACE_FOREGROUND, false)?
     .visit_field::<Color>("muted", Self::VT_MUTED, false)?
     .visit_field::<Color>("muted_foreground", Self::VT_MUTED_FOREGROUND, false)?
     .visit_field::<Color>("border_color", Self::VT_BORDER_COLOR, false)?
     .visit_field::<Color>("error", Self::VT_ERROR, false)?
     .visit_field::<Color>("error_foreground", Self::VT_ERROR_FOREGROUND, false)?
     .visit_field::<Color>("success", Self::VT_SUCCESS, false)?
     .visit_field::<Color>("success_foreground", Self::VT_SUCCESS_FOREGROUND, false)?
     .visit_field::<Color>("warning", Self::VT_WARNING, false)?
     .visit_field::<Color>("warning_foreground", Self::VT_WARNING_FOREGROUND, false)?
     .visit_field::<Color>("info", Self::VT_INFO, false)?
     .visit_field::<Color>("info_foreground", Self::VT_INFO_FOREGROUND, false)?
     .finish();
    Ok(())
  }
}
pub struct ColorPaletteArgs<'a> {
    pub primary: Option<&'a Color>,
    pub primary_foreground: Option<&'a Color>,
    pub secondary: Option<&'a Color>,
    pub secondary_foreground: Option<&'a Color>,
    pub accent: Option<&'a Color>,
    pub accent_foreground: Option<&'a Color>,
    pub background: Option<&'a Color>,
    pub foreground: Option<&'a Color>,
    pub surface: Option<&'a Color>,
    pub surface_foreground: Option<&'a Color>,
    pub muted: Option<&'a Color>,
    pub muted_foreground: Option<&'a Color>,
    pub border_color: Option<&'a Color>,
    pub error: Option<&'a Color>,
    pub error_foreground: Option<&'a Color>,
    pub success: Option<&'a Color>,
    pub success_foreground: Option<&'a Color>,
    pub warning: Option<&'a Color>,
    pub warning_foreground: Option<&'a Color>,
    pub info: Option<&'a Color>,
    pub info_foreground: Option<&'a Color>,
}
impl<'a> Default for ColorPaletteArgs<'a> {
  #[inline]
  fn default() -> Self {
    ColorPaletteArgs {
      primary: None,
      primary_foreground: None,
      secondary: None,
      secondary_foreground: None,
      accent: None,
      accent_foreground: None,
      background: None,
      foreground: None,
      surface: None,
      surface_foreground: None,
      muted: None,
      muted_foreground: None,
      border_color: None,
      error: None,
      error_foreground: None,
      success: None,
      success_foreground: None,
      warning: None,
      warning_foreground: None,
      info: None,
      info_foreground: None,
    }
  }
}

pub struct ColorPaletteBuilder<'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> ColorPaletteBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_primary(&mut self, primary: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_PRIMARY, primary);
  }
  #[inline]
  pub fn add_primary_foreground(&mut self, primary_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_PRIMARY_FOREGROUND, primary_foreground);
  }
  #[inline]
  pub fn add_secondary(&mut self, secondary: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SECONDARY, secondary);
  }
  #[inline]
  pub fn add_secondary_foreground(&mut self, secondary_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SECONDARY_FOREGROUND, secondary_foreground);
  }
  #[inline]
  pub fn add_accent(&mut self, accent: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_ACCENT, accent);
  }
  #[inline]
  pub fn add_accent_foreground(&mut self, accent_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_ACCENT_FOREGROUND, accent_foreground);
  }
  #[inline]
  pub fn add_background(&mut self, background: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_BACKGROUND, background);
  }
  #[inline]
  pub fn add_foreground(&mut self, foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_FOREGROUND, foreground);
  }
  #[inline]
  pub fn add_surface(&mut self, surface: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SURFACE, surface);
  }
  #[inline]
  pub fn add_surface_foreground(&mut self, surface_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SURFACE_FOREGROUND, surface_foreground);
  }
  #[inline]
  pub fn add_muted(&mut self, muted: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_MUTED, muted);
  }
  #[inline]
  pub fn add_muted_foreground(&mut self, muted_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_MUTED_FOREGROUND, muted_foreground);
  }
  #[inline]
  pub fn add_border_color(&mut self, border_color: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_BORDER_COLOR, border_color);
  }
  #[inline]
  pub fn add_error(&mut self, error: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_ERROR, error);
  }
  #[inline]
  pub fn add_error_foreground(&mut self, error_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_ERROR_FOREGROUND, error_foreground);
  }
  #[inline]
  pub fn add_success(&mut self, success: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SUCCESS, success);
  }
  #[inline]
  pub fn add_success_foreground(&mut self, success_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_SUCCESS_FOREGROUND, success_foreground);
  }
  #[inline]
  pub fn add_warning(&mut self, warning: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_WARNING, warning);
  }
  #[inline]
  pub fn add_warning_foreground(&mut self, warning_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_WARNING_FOREGROUND, warning_foreground);
  }
  #[inline]
  pub fn add_info(&mut self, info: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_INFO, info);
  }
  #[inline]
  pub fn add_info_foreground(&mut self, info_foreground: &Color) {
    self.fbb_.push_slot_always::<&Color>(ColorPalette::VT_INFO_FOREGROUND, info_foreground);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ColorPaletteBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ColorPaletteBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ColorPalette<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ColorPalette<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ColorPalette");
      ds.field("primary", &self.primary());
      ds.field("primary_foreground", &self.primary_foreground());
      ds.field("secondary", &self.secondary());
      ds.field("secondary_foreground", &self.secondary_foreground());
      ds.field("accent", &self.accent());
      ds.field("accent_foreground", &self.accent_foreground());
      ds.field("background", &self.background());
      ds.field("foreground", &self.foreground());
      ds.field("surface", &self.surface());
      ds.field("surface_foreground", &self.surface_foreground());
      ds.field("muted", &self.muted());
      ds.field("muted_foreground", &self.muted_foreground());
      ds.field("border_color", &self.border_color());
      ds.field("error", &self.error());
      ds.field("error_foreground", &self.error_foreground());
      ds.field("success", &self.success());
      ds.field("success_foreground", &self.success_foreground());
      ds.field("warning", &self.warning());
      ds.field("warning_foreground", &self.warning_foreground());
      ds.field("info", &self.info());
      ds.field("info_foreground", &self.info_foreground());
      ds.finish()
  }
}
pub enum FontDefinitionOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> FontDefinition<'a> {
  pub const VT_FAMILY: flatbuffers::VOffsetT = 4;
  pub const VT_SRC: flatbuffers::VOffsetT = 6;
  pub const VT_WEIGHT_RANGE: flatbuffers::VOffsetT = 8;
  pub const VT_VARIABLE: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FontDefinition { _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 FontDefinitionArgs<'args>
  ) -> flatbuffers::WIPOffset<FontDefinition<'bldr>> {
    let mut builder = FontDefinitionBuilder::new(_fbb);
    if let Some(x) = args.weight_range { builder.add_weight_range(x); }
    if let Some(x) = args.src { builder.add_src(x); }
    if let Some(x) = args.family { builder.add_family(x); }
    builder.add_variable(args.variable);
    builder.finish()
  }


  #[inline]
  pub fn family(&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>>(FontDefinition::VT_FAMILY, None).unwrap()}
  }
  /// URL to font file (for compiler to subset and optimize).
  #[inline]
  pub fn src(&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>>(FontDefinition::VT_SRC, None)}
  }
  /// Weight range for variable fonts (e.g., "100 900").
  #[inline]
  pub fn weight_range(&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>>(FontDefinition::VT_WEIGHT_RANGE, None)}
  }
  /// Whether this is a variable font.
  #[inline]
  pub fn variable(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(FontDefinition::VT_VARIABLE, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for FontDefinition<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("family", Self::VT_FAMILY, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("src", Self::VT_SRC, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weight_range", Self::VT_WEIGHT_RANGE, false)?
     .visit_field::<bool>("variable", Self::VT_VARIABLE, false)?
     .finish();
    Ok(())
  }
}
pub struct FontDefinitionArgs<'a> {
    pub family: Option<flatbuffers::WIPOffset<&'a str>>,
    pub src: Option<flatbuffers::WIPOffset<&'a str>>,
    pub weight_range: Option<flatbuffers::WIPOffset<&'a str>>,
    pub variable: bool,
}
impl<'a> Default for FontDefinitionArgs<'a> {
  #[inline]
  fn default() -> Self {
    FontDefinitionArgs {
      family: None, // required field
      src: None,
      weight_range: None,
      variable: false,
    }
  }
}

pub struct FontDefinitionBuilder<'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> FontDefinitionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_family(&mut self, family: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FontDefinition::VT_FAMILY, family);
  }
  #[inline]
  pub fn add_src(&mut self, src: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FontDefinition::VT_SRC, src);
  }
  #[inline]
  pub fn add_weight_range(&mut self, weight_range: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FontDefinition::VT_WEIGHT_RANGE, weight_range);
  }
  #[inline]
  pub fn add_variable(&mut self, variable: bool) {
    self.fbb_.push_slot::<bool>(FontDefinition::VT_VARIABLE, variable, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FontDefinitionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FontDefinitionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FontDefinition<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FontDefinition::VT_FAMILY,"family");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> TypographyScale<'a> {
  pub const VT_FONT_BODY: flatbuffers::VOffsetT = 4;
  pub const VT_FONT_DISPLAY: flatbuffers::VOffsetT = 6;
  pub const VT_FONT_MONO: flatbuffers::VOffsetT = 8;
  pub const VT_SIZE_SCALE: flatbuffers::VOffsetT = 10;
  pub const VT_LINE_HEIGHT_SCALE: flatbuffers::VOffsetT = 12;
  pub const VT_LETTER_SPACING: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    TypographyScale { _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 TypographyScaleArgs<'args>
  ) -> flatbuffers::WIPOffset<TypographyScale<'bldr>> {
    let mut builder = TypographyScaleBuilder::new(_fbb);
    if let Some(x) = args.letter_spacing { builder.add_letter_spacing(x); }
    if let Some(x) = args.line_height_scale { builder.add_line_height_scale(x); }
    if let Some(x) = args.size_scale { builder.add_size_scale(x); }
    if let Some(x) = args.font_mono { builder.add_font_mono(x); }
    if let Some(x) = args.font_display { builder.add_font_display(x); }
    if let Some(x) = args.font_body { builder.add_font_body(x); }
    builder.finish()
  }


  #[inline]
  pub fn font_body(&self) -> Option<FontDefinition<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FontDefinition>>(TypographyScale::VT_FONT_BODY, None)}
  }
  #[inline]
  pub fn font_display(&self) -> Option<FontDefinition<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FontDefinition>>(TypographyScale::VT_FONT_DISPLAY, None)}
  }
  #[inline]
  pub fn font_mono(&self) -> Option<FontDefinition<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FontDefinition>>(TypographyScale::VT_FONT_MONO, None)}
  }
  /// Size scale (indexes: 0=xs, 1=sm, 2=base, 3=lg, 4=xl, 5=2xl, 6=3xl, 7=4xl).
  #[inline]
  pub fn size_scale(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'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<Length>>>>(TypographyScale::VT_SIZE_SCALE, None)}
  }
  /// Line height scale (matching size_scale indexes).
  #[inline]
  pub fn line_height_scale(&self) -> Option<flatbuffers::Vector<'a, f32>> {
    // 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, f32>>>(TypographyScale::VT_LINE_HEIGHT_SCALE, None)}
  }
  /// Default letter spacing.
  #[inline]
  pub fn letter_spacing(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(TypographyScale::VT_LETTER_SPACING, None)}
  }
}

impl flatbuffers::Verifiable for TypographyScale<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<FontDefinition>>("font_body", Self::VT_FONT_BODY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<FontDefinition>>("font_display", Self::VT_FONT_DISPLAY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<FontDefinition>>("font_mono", Self::VT_FONT_MONO, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Length>>>>("size_scale", Self::VT_SIZE_SCALE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>("line_height_scale", Self::VT_LINE_HEIGHT_SCALE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("letter_spacing", Self::VT_LETTER_SPACING, false)?
     .finish();
    Ok(())
  }
}
pub struct TypographyScaleArgs<'a> {
    pub font_body: Option<flatbuffers::WIPOffset<FontDefinition<'a>>>,
    pub font_display: Option<flatbuffers::WIPOffset<FontDefinition<'a>>>,
    pub font_mono: Option<flatbuffers::WIPOffset<FontDefinition<'a>>>,
    pub size_scale: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'a>>>>>,
    pub line_height_scale: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
    pub letter_spacing: Option<flatbuffers::WIPOffset<Length<'a>>>,
}
impl<'a> Default for TypographyScaleArgs<'a> {
  #[inline]
  fn default() -> Self {
    TypographyScaleArgs {
      font_body: None,
      font_display: None,
      font_mono: None,
      size_scale: None,
      line_height_scale: None,
      letter_spacing: None,
    }
  }
}

pub struct TypographyScaleBuilder<'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> TypographyScaleBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_font_body(&mut self, font_body: flatbuffers::WIPOffset<FontDefinition<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FontDefinition>>(TypographyScale::VT_FONT_BODY, font_body);
  }
  #[inline]
  pub fn add_font_display(&mut self, font_display: flatbuffers::WIPOffset<FontDefinition<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FontDefinition>>(TypographyScale::VT_FONT_DISPLAY, font_display);
  }
  #[inline]
  pub fn add_font_mono(&mut self, font_mono: flatbuffers::WIPOffset<FontDefinition<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FontDefinition>>(TypographyScale::VT_FONT_MONO, font_mono);
  }
  #[inline]
  pub fn add_size_scale(&mut self, size_scale: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Length<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypographyScale::VT_SIZE_SCALE, size_scale);
  }
  #[inline]
  pub fn add_line_height_scale(&mut self, line_height_scale: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TypographyScale::VT_LINE_HEIGHT_SCALE, line_height_scale);
  }
  #[inline]
  pub fn add_letter_spacing(&mut self, letter_spacing: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(TypographyScale::VT_LETTER_SPACING, letter_spacing);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TypographyScaleBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TypographyScaleBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<TypographyScale<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for TypographyScale<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("TypographyScale");
      ds.field("font_body", &self.font_body());
      ds.field("font_display", &self.font_display());
      ds.field("font_mono", &self.font_mono());
      ds.field("size_scale", &self.size_scale());
      ds.field("line_height_scale", &self.line_height_scale());
      ds.field("letter_spacing", &self.letter_spacing());
      ds.finish()
  }
}
pub enum SpacingScaleOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> SpacingScale<'a> {
  pub const VT_BASE: flatbuffers::VOffsetT = 4;
  pub const VT_MULTIPLIERS: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SpacingScale { _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 SpacingScaleArgs<'args>
  ) -> flatbuffers::WIPOffset<SpacingScale<'bldr>> {
    let mut builder = SpacingScaleBuilder::new(_fbb);
    if let Some(x) = args.multipliers { builder.add_multipliers(x); }
    if let Some(x) = args.base { builder.add_base(x); }
    builder.finish()
  }


  /// Base spacing unit (e.g., 4px or 0.25rem).
  #[inline]
  pub fn base(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(SpacingScale::VT_BASE, None)}
  }
  /// Multiplier scale (e.g., [0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64]).
  /// Actual spacing = base.value * multiplier[i].
  #[inline]
  pub fn multipliers(&self) -> Option<flatbuffers::Vector<'a, f32>> {
    // 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, f32>>>(SpacingScale::VT_MULTIPLIERS, None)}
  }
}

impl flatbuffers::Verifiable for SpacingScale<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("base", Self::VT_BASE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>("multipliers", Self::VT_MULTIPLIERS, false)?
     .finish();
    Ok(())
  }
}
pub struct SpacingScaleArgs<'a> {
    pub base: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub multipliers: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
}
impl<'a> Default for SpacingScaleArgs<'a> {
  #[inline]
  fn default() -> Self {
    SpacingScaleArgs {
      base: None,
      multipliers: None,
    }
  }
}

pub struct SpacingScaleBuilder<'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> SpacingScaleBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_base(&mut self, base: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(SpacingScale::VT_BASE, base);
  }
  #[inline]
  pub fn add_multipliers(&mut self, multipliers: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SpacingScale::VT_MULTIPLIERS, multipliers);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SpacingScaleBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SpacingScaleBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SpacingScale<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ShadowScale<'a> {
  pub const VT_SHADOWS: flatbuffers::VOffsetT = 4;

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


  /// Named shadows: sm, md, lg, xl, 2xl (indexed).
  #[inline]
  pub fn shadows(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Shadow<'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<Shadow>>>>(ShadowScale::VT_SHADOWS, None)}
  }
}

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

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

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

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

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

impl<'a> RadiusScale<'a> {
  pub const VT_RADII: flatbuffers::VOffsetT = 4;

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


  /// Named radii: none, sm, md, lg, xl, full (indexed).
  #[inline]
  pub fn radii(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'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<Length>>>>(RadiusScale::VT_RADII, None)}
  }
}

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

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

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

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

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

impl<'a> ThemeNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_COLORS: flatbuffers::VOffsetT = 8;
  pub const VT_TYPOGRAPHY: flatbuffers::VOffsetT = 10;
  pub const VT_SPACING: flatbuffers::VOffsetT = 12;
  pub const VT_SHADOWS: flatbuffers::VOffsetT = 14;
  pub const VT_RADII: flatbuffers::VOffsetT = 16;
  pub const VT_TRANSITION_DURATION: flatbuffers::VOffsetT = 18;
  pub const VT_TRANSITION_EASING: flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ThemeNode { _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 ThemeNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<ThemeNode<'bldr>> {
    let mut builder = ThemeNodeBuilder::new(_fbb);
    if let Some(x) = args.transition_easing { builder.add_transition_easing(x); }
    if let Some(x) = args.transition_duration { builder.add_transition_duration(x); }
    if let Some(x) = args.radii { builder.add_radii(x); }
    if let Some(x) = args.shadows { builder.add_shadows(x); }
    if let Some(x) = args.spacing { builder.add_spacing(x); }
    if let Some(x) = args.typography { builder.add_typography(x); }
    if let Some(x) = args.colors { builder.add_colors(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ThemeNode::VT_NODE_ID, None).unwrap()}
  }
  /// Theme name (e.g., "light", "dark", "high-contrast").
  #[inline]
  pub fn name(&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>>(ThemeNode::VT_NAME, None).unwrap()}
  }
  #[inline]
  pub fn colors(&self) -> Option<ColorPalette<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ColorPalette>>(ThemeNode::VT_COLORS, None)}
  }
  #[inline]
  pub fn typography(&self) -> Option<TypographyScale<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<TypographyScale>>(ThemeNode::VT_TYPOGRAPHY, None)}
  }
  #[inline]
  pub fn spacing(&self) -> Option<SpacingScale<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<SpacingScale>>(ThemeNode::VT_SPACING, None)}
  }
  #[inline]
  pub fn shadows(&self) -> Option<ShadowScale<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ShadowScale>>(ThemeNode::VT_SHADOWS, None)}
  }
  #[inline]
  pub fn radii(&self) -> Option<RadiusScale<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RadiusScale>>(ThemeNode::VT_RADII, None)}
  }
  /// Transition animation when switching to this theme.
  #[inline]
  pub fn transition_duration(&self) -> Option<Duration<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Duration>>(ThemeNode::VT_TRANSITION_DURATION, None)}
  }
  #[inline]
  pub fn transition_easing(&self) -> Option<Easing<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Easing>>(ThemeNode::VT_TRANSITION_EASING, None)}
  }
}

impl flatbuffers::Verifiable for ThemeNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ColorPalette>>("colors", Self::VT_COLORS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<TypographyScale>>("typography", Self::VT_TYPOGRAPHY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<SpacingScale>>("spacing", Self::VT_SPACING, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ShadowScale>>("shadows", Self::VT_SHADOWS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<RadiusScale>>("radii", Self::VT_RADII, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Duration>>("transition_duration", Self::VT_TRANSITION_DURATION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Easing>>("transition_easing", Self::VT_TRANSITION_EASING, false)?
     .finish();
    Ok(())
  }
}
pub struct ThemeNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub colors: Option<flatbuffers::WIPOffset<ColorPalette<'a>>>,
    pub typography: Option<flatbuffers::WIPOffset<TypographyScale<'a>>>,
    pub spacing: Option<flatbuffers::WIPOffset<SpacingScale<'a>>>,
    pub shadows: Option<flatbuffers::WIPOffset<ShadowScale<'a>>>,
    pub radii: Option<flatbuffers::WIPOffset<RadiusScale<'a>>>,
    pub transition_duration: Option<flatbuffers::WIPOffset<Duration<'a>>>,
    pub transition_easing: Option<flatbuffers::WIPOffset<Easing<'a>>>,
}
impl<'a> Default for ThemeNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    ThemeNodeArgs {
      node_id: None, // required field
      name: None, // required field
      colors: None,
      typography: None,
      spacing: None,
      shadows: None,
      radii: None,
      transition_duration: None,
      transition_easing: None,
    }
  }
}

pub struct ThemeNodeBuilder<'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> ThemeNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ThemeNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ThemeNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_colors(&mut self, colors: flatbuffers::WIPOffset<ColorPalette<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ColorPalette>>(ThemeNode::VT_COLORS, colors);
  }
  #[inline]
  pub fn add_typography(&mut self, typography: flatbuffers::WIPOffset<TypographyScale<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<TypographyScale>>(ThemeNode::VT_TYPOGRAPHY, typography);
  }
  #[inline]
  pub fn add_spacing(&mut self, spacing: flatbuffers::WIPOffset<SpacingScale<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<SpacingScale>>(ThemeNode::VT_SPACING, spacing);
  }
  #[inline]
  pub fn add_shadows(&mut self, shadows: flatbuffers::WIPOffset<ShadowScale<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ShadowScale>>(ThemeNode::VT_SHADOWS, shadows);
  }
  #[inline]
  pub fn add_radii(&mut self, radii: flatbuffers::WIPOffset<RadiusScale<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RadiusScale>>(ThemeNode::VT_RADII, radii);
  }
  #[inline]
  pub fn add_transition_duration(&mut self, transition_duration: flatbuffers::WIPOffset<Duration<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Duration>>(ThemeNode::VT_TRANSITION_DURATION, transition_duration);
  }
  #[inline]
  pub fn add_transition_easing(&mut self, transition_easing: flatbuffers::WIPOffset<Easing<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Easing>>(ThemeNode::VT_TRANSITION_EASING, transition_easing);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ThemeNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ThemeNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ThemeNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ThemeNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ThemeNode::VT_NAME,"name");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ThemeNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ThemeNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("colors", &self.colors());
      ds.field("typography", &self.typography());
      ds.field("spacing", &self.spacing());
      ds.field("shadows", &self.shadows());
      ds.field("radii", &self.radii());
      ds.field("transition_duration", &self.transition_duration());
      ds.field("transition_easing", &self.transition_easing());
      ds.finish()
  }
}
pub enum PersonalizationConditionOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> PersonalizationCondition<'a> {
  pub const VT_CONDITION_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_OPERATOR: flatbuffers::VOffsetT = 6;
  pub const VT_VALUE: flatbuffers::VOffsetT = 8;

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


  #[inline]
  pub fn condition_type(&self) -> PersonalizationConditionType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<PersonalizationConditionType>(PersonalizationCondition::VT_CONDITION_TYPE, Some(PersonalizationConditionType::Locale)).unwrap()}
  }
  /// Operator: "eq", "neq", "gt", "lt", "gte", "lte", "contains".
  #[inline]
  pub fn operator(&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>>(PersonalizationCondition::VT_OPERATOR, None)}
  }
  /// Value to compare against (e.g., "dark", "mobile", "en-US").
  #[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>>(PersonalizationCondition::VT_VALUE, None)}
  }
}

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

pub struct PersonalizationConditionBuilder<'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> PersonalizationConditionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_condition_type(&mut self, condition_type: PersonalizationConditionType) {
    self.fbb_.push_slot::<PersonalizationConditionType>(PersonalizationCondition::VT_CONDITION_TYPE, condition_type, PersonalizationConditionType::Locale);
  }
  #[inline]
  pub fn add_operator(&mut self, operator: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationCondition::VT_OPERATOR, operator);
  }
  #[inline]
  pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationCondition::VT_VALUE, value);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PersonalizationConditionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PersonalizationConditionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<PersonalizationCondition<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> PersonalizationVariant<'a> {
  pub const VT_CONDITIONS: flatbuffers::VOffsetT = 4;
  pub const VT_SHOW_NODES: flatbuffers::VOffsetT = 6;
  pub const VT_HIDE_NODES: flatbuffers::VOffsetT = 8;
  pub const VT_OVERRIDES: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    PersonalizationVariant { _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 PersonalizationVariantArgs<'args>
  ) -> flatbuffers::WIPOffset<PersonalizationVariant<'bldr>> {
    let mut builder = PersonalizationVariantBuilder::new(_fbb);
    if let Some(x) = args.overrides { builder.add_overrides(x); }
    if let Some(x) = args.hide_nodes { builder.add_hide_nodes(x); }
    if let Some(x) = args.show_nodes { builder.add_show_nodes(x); }
    if let Some(x) = args.conditions { builder.add_conditions(x); }
    builder.finish()
  }


  /// Conditions that must all be true for this variant to activate.
  #[inline]
  pub fn conditions(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PersonalizationCondition<'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<PersonalizationCondition>>>>(PersonalizationVariant::VT_CONDITIONS, None).unwrap()}
  }
  /// Node IDs to show when this variant is active.
  #[inline]
  pub fn show_nodes(&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>>>>(PersonalizationVariant::VT_SHOW_NODES, None)}
  }
  /// Node IDs to hide when this variant is active.
  #[inline]
  pub fn hide_nodes(&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>>>>(PersonalizationVariant::VT_HIDE_NODES, None)}
  }
  /// Property overrides to apply (node_id + property + value).
  #[inline]
  pub fn overrides(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PropertyOverride<'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<PropertyOverride>>>>(PersonalizationVariant::VT_OVERRIDES, None)}
  }
}

impl flatbuffers::Verifiable for PersonalizationVariant<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PersonalizationCondition>>>>("conditions", Self::VT_CONDITIONS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("show_nodes", Self::VT_SHOW_NODES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("hide_nodes", Self::VT_HIDE_NODES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PropertyOverride>>>>("overrides", Self::VT_OVERRIDES, false)?
     .finish();
    Ok(())
  }
}
pub struct PersonalizationVariantArgs<'a> {
    pub conditions: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PersonalizationCondition<'a>>>>>,
    pub show_nodes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub hide_nodes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub overrides: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PropertyOverride<'a>>>>>,
}
impl<'a> Default for PersonalizationVariantArgs<'a> {
  #[inline]
  fn default() -> Self {
    PersonalizationVariantArgs {
      conditions: None, // required field
      show_nodes: None,
      hide_nodes: None,
      overrides: None,
    }
  }
}

pub struct PersonalizationVariantBuilder<'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> PersonalizationVariantBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_conditions(&mut self, conditions: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<PersonalizationCondition<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationVariant::VT_CONDITIONS, conditions);
  }
  #[inline]
  pub fn add_show_nodes(&mut self, show_nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationVariant::VT_SHOW_NODES, show_nodes);
  }
  #[inline]
  pub fn add_hide_nodes(&mut self, hide_nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationVariant::VT_HIDE_NODES, hide_nodes);
  }
  #[inline]
  pub fn add_overrides(&mut self, overrides: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<PropertyOverride<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationVariant::VT_OVERRIDES, overrides);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PersonalizationVariantBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PersonalizationVariantBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<PersonalizationVariant<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, PersonalizationVariant::VT_CONDITIONS,"conditions");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> PropertyOverride<'a> {
  pub const VT_TARGET_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_PROPERTY: flatbuffers::VOffsetT = 6;
  pub const VT_VALUE: flatbuffers::VOffsetT = 8;

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


  #[inline]
  pub fn target_node_id(&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>>(PropertyOverride::VT_TARGET_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn property(&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>>(PropertyOverride::VT_PROPERTY, 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>>(PropertyOverride::VT_VALUE, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for PropertyOverride<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_node_id", Self::VT_TARGET_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("property", Self::VT_PROPERTY, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, true)?
     .finish();
    Ok(())
  }
}
pub struct PropertyOverrideArgs<'a> {
    pub target_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub property: Option<flatbuffers::WIPOffset<&'a str>>,
    pub value: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for PropertyOverrideArgs<'a> {
  #[inline]
  fn default() -> Self {
    PropertyOverrideArgs {
      target_node_id: None, // required field
      property: None, // required field
      value: None, // required field
    }
  }
}

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

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

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

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

impl<'a> PersonalizationSlot<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_VARIANTS: flatbuffers::VOffsetT = 8;
  pub const VT_DEFAULT_VARIANT_INDEX: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    PersonalizationSlot { _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 PersonalizationSlotArgs<'args>
  ) -> flatbuffers::WIPOffset<PersonalizationSlot<'bldr>> {
    let mut builder = PersonalizationSlotBuilder::new(_fbb);
    builder.add_default_variant_index(args.default_variant_index);
    if let Some(x) = args.variants { builder.add_variants(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(PersonalizationSlot::VT_NODE_ID, None).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>>(PersonalizationSlot::VT_NAME, None)}
  }
  #[inline]
  pub fn variants(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PersonalizationVariant<'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<PersonalizationVariant>>>>(PersonalizationSlot::VT_VARIANTS, None).unwrap()}
  }
  /// Fallback: what to show if no variant matches.
  #[inline]
  pub fn default_variant_index(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(PersonalizationSlot::VT_DEFAULT_VARIANT_INDEX, Some(0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for PersonalizationSlot<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PersonalizationVariant>>>>("variants", Self::VT_VARIANTS, true)?
     .visit_field::<i32>("default_variant_index", Self::VT_DEFAULT_VARIANT_INDEX, false)?
     .finish();
    Ok(())
  }
}
pub struct PersonalizationSlotArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub variants: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PersonalizationVariant<'a>>>>>,
    pub default_variant_index: i32,
}
impl<'a> Default for PersonalizationSlotArgs<'a> {
  #[inline]
  fn default() -> Self {
    PersonalizationSlotArgs {
      node_id: None, // required field
      name: None,
      variants: None, // required field
      default_variant_index: 0,
    }
  }
}

pub struct PersonalizationSlotBuilder<'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> PersonalizationSlotBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationSlot::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationSlot::VT_NAME, name);
  }
  #[inline]
  pub fn add_variants(&mut self, variants: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<PersonalizationVariant<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PersonalizationSlot::VT_VARIANTS, variants);
  }
  #[inline]
  pub fn add_default_variant_index(&mut self, default_variant_index: i32) {
    self.fbb_.push_slot::<i32>(PersonalizationSlot::VT_DEFAULT_VARIANT_INDEX, default_variant_index, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PersonalizationSlotBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PersonalizationSlotBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<PersonalizationSlot<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, PersonalizationSlot::VT_NODE_ID,"node_id");
    self.fbb_.required(o, PersonalizationSlot::VT_VARIANTS,"variants");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Breakpoint<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_MIN_WIDTH: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Breakpoint { _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 BreakpointArgs<'args>
  ) -> flatbuffers::WIPOffset<Breakpoint<'bldr>> {
    let mut builder = BreakpointBuilder::new(_fbb);
    if let Some(x) = args.min_width { builder.add_min_width(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.finish()
  }


  /// Breakpoint name (e.g., "sm", "md", "lg", "xl", "2xl").
  #[inline]
  pub fn name(&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>>(Breakpoint::VT_NAME, None).unwrap()}
  }
  /// Minimum viewport width for this breakpoint.
  #[inline]
  pub fn min_width(&self) -> Length<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Breakpoint::VT_MIN_WIDTH, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for Breakpoint<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("min_width", Self::VT_MIN_WIDTH, true)?
     .finish();
    Ok(())
  }
}
pub struct BreakpointArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub min_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
}
impl<'a> Default for BreakpointArgs<'a> {
  #[inline]
  fn default() -> Self {
    BreakpointArgs {
      name: None, // required field
      min_width: None, // required field
    }
  }
}

pub struct BreakpointBuilder<'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> BreakpointBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Breakpoint::VT_NAME, name);
  }
  #[inline]
  pub fn add_min_width(&mut self, min_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Breakpoint::VT_MIN_WIDTH, min_width);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> BreakpointBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    BreakpointBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Breakpoint<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Breakpoint::VT_NAME,"name");
    self.fbb_.required(o, Breakpoint::VT_MIN_WIDTH,"min_width");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ResponsiveOverride<'a> {
  pub const VT_BREAKPOINT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_OVERRIDES: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ResponsiveOverride { _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 ResponsiveOverrideArgs<'args>
  ) -> flatbuffers::WIPOffset<ResponsiveOverride<'bldr>> {
    let mut builder = ResponsiveOverrideBuilder::new(_fbb);
    if let Some(x) = args.overrides { builder.add_overrides(x); }
    if let Some(x) = args.breakpoint_name { builder.add_breakpoint_name(x); }
    builder.finish()
  }


  /// Which breakpoint this override applies at.
  #[inline]
  pub fn breakpoint_name(&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>>(ResponsiveOverride::VT_BREAKPOINT_NAME, None).unwrap()}
  }
  /// Property overrides at this breakpoint.
  #[inline]
  pub fn overrides(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PropertyOverride<'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<PropertyOverride>>>>(ResponsiveOverride::VT_OVERRIDES, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for ResponsiveOverride<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("breakpoint_name", Self::VT_BREAKPOINT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PropertyOverride>>>>("overrides", Self::VT_OVERRIDES, true)?
     .finish();
    Ok(())
  }
}
pub struct ResponsiveOverrideArgs<'a> {
    pub breakpoint_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub overrides: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PropertyOverride<'a>>>>>,
}
impl<'a> Default for ResponsiveOverrideArgs<'a> {
  #[inline]
  fn default() -> Self {
    ResponsiveOverrideArgs {
      breakpoint_name: None, // required field
      overrides: None, // required field
    }
  }
}

pub struct ResponsiveOverrideBuilder<'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> ResponsiveOverrideBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_breakpoint_name(&mut self, breakpoint_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ResponsiveOverride::VT_BREAKPOINT_NAME, breakpoint_name);
  }
  #[inline]
  pub fn add_overrides(&mut self, overrides: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<PropertyOverride<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ResponsiveOverride::VT_OVERRIDES, overrides);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ResponsiveOverrideBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ResponsiveOverrideBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ResponsiveOverride<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ResponsiveOverride::VT_BREAKPOINT_NAME,"breakpoint_name");
    self.fbb_.required(o, ResponsiveOverride::VT_OVERRIDES,"overrides");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ResponsiveRule<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_BREAKPOINTS: flatbuffers::VOffsetT = 6;
  pub const VT_RESPONSIVE_OVERRIDES: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ResponsiveRule { _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 ResponsiveRuleArgs<'args>
  ) -> flatbuffers::WIPOffset<ResponsiveRule<'bldr>> {
    let mut builder = ResponsiveRuleBuilder::new(_fbb);
    if let Some(x) = args.responsive_overrides { builder.add_responsive_overrides(x); }
    if let Some(x) = args.breakpoints { builder.add_breakpoints(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ResponsiveRule::VT_NODE_ID, None).unwrap()}
  }
  /// Breakpoint definitions (shared across the rule).
  #[inline]
  pub fn breakpoints(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Breakpoint<'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<Breakpoint>>>>(ResponsiveRule::VT_BREAKPOINTS, None).unwrap()}
  }
  /// Per-breakpoint property overrides.
  #[inline]
  pub fn responsive_overrides(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ResponsiveOverride<'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<ResponsiveOverride>>>>(ResponsiveRule::VT_RESPONSIVE_OVERRIDES, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for ResponsiveRule<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Breakpoint>>>>("breakpoints", Self::VT_BREAKPOINTS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ResponsiveOverride>>>>("responsive_overrides", Self::VT_RESPONSIVE_OVERRIDES, true)?
     .finish();
    Ok(())
  }
}
pub struct ResponsiveRuleArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub breakpoints: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Breakpoint<'a>>>>>,
    pub responsive_overrides: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ResponsiveOverride<'a>>>>>,
}
impl<'a> Default for ResponsiveRuleArgs<'a> {
  #[inline]
  fn default() -> Self {
    ResponsiveRuleArgs {
      node_id: None, // required field
      breakpoints: None, // required field
      responsive_overrides: None, // required field
    }
  }
}

pub struct ResponsiveRuleBuilder<'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> ResponsiveRuleBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ResponsiveRule::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_breakpoints(&mut self, breakpoints: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Breakpoint<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ResponsiveRule::VT_BREAKPOINTS, breakpoints);
  }
  #[inline]
  pub fn add_responsive_overrides(&mut self, responsive_overrides: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ResponsiveOverride<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ResponsiveRule::VT_RESPONSIVE_OVERRIDES, responsive_overrides);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ResponsiveRuleBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ResponsiveRuleBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ResponsiveRule<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ResponsiveRule::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ResponsiveRule::VT_BREAKPOINTS,"breakpoints");
    self.fbb_.required(o, ResponsiveRule::VT_RESPONSIVE_OVERRIDES,"responsive_overrides");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RetryConfig<'a> {
  pub const VT_MAX_ATTEMPTS: flatbuffers::VOffsetT = 4;
  pub const VT_BACKOFF: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RetryConfig { _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 RetryConfigArgs<'args>
  ) -> flatbuffers::WIPOffset<RetryConfig<'bldr>> {
    let mut builder = RetryConfigBuilder::new(_fbb);
    if let Some(x) = args.backoff { builder.add_backoff(x); }
    builder.add_max_attempts(args.max_attempts);
    builder.finish()
  }


  #[inline]
  pub fn max_attempts(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(RetryConfig::VT_MAX_ATTEMPTS, Some(3)).unwrap()}
  }
  /// Backoff strategy: "exponential" or "linear".
  #[inline]
  pub fn backoff(&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>>(RetryConfig::VT_BACKOFF, None)}
  }
}

impl flatbuffers::Verifiable for RetryConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<i32>("max_attempts", Self::VT_MAX_ATTEMPTS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("backoff", Self::VT_BACKOFF, false)?
     .finish();
    Ok(())
  }
}
pub struct RetryConfigArgs<'a> {
    pub max_attempts: i32,
    pub backoff: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for RetryConfigArgs<'a> {
  #[inline]
  fn default() -> Self {
    RetryConfigArgs {
      max_attempts: 3,
      backoff: None,
    }
  }
}

pub struct RetryConfigBuilder<'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> RetryConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_max_attempts(&mut self, max_attempts: i32) {
    self.fbb_.push_slot::<i32>(RetryConfig::VT_MAX_ATTEMPTS, max_attempts, 3);
  }
  #[inline]
  pub fn add_backoff(&mut self, backoff: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RetryConfig::VT_BACKOFF, backoff);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RetryConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RetryConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RetryConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> OptimisticConfig<'a> {
  pub const VT_STRATEGY: flatbuffers::VOffsetT = 4;
  pub const VT_TARGET_DATA_NODE_ID: flatbuffers::VOffsetT = 6;
  pub const VT_ROLLBACK: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    OptimisticConfig { _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 OptimisticConfigArgs<'args>
  ) -> flatbuffers::WIPOffset<OptimisticConfig<'bldr>> {
    let mut builder = OptimisticConfigBuilder::new(_fbb);
    if let Some(x) = args.target_data_node_id { builder.add_target_data_node_id(x); }
    builder.add_rollback(args.rollback);
    builder.add_strategy(args.strategy);
    builder.finish()
  }


  #[inline]
  pub fn strategy(&self) -> OptimisticStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<OptimisticStrategy>(OptimisticConfig::VT_STRATEGY, Some(OptimisticStrategy::None)).unwrap()}
  }
  /// Which DataNode to optimistically update.
  #[inline]
  pub fn target_data_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(OptimisticConfig::VT_TARGET_DATA_NODE_ID, None)}
  }
  #[inline]
  pub fn rollback(&self) -> RollbackStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<RollbackStrategy>(OptimisticConfig::VT_ROLLBACK, Some(RollbackStrategy::Revert)).unwrap()}
  }
}

impl flatbuffers::Verifiable for OptimisticConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<OptimisticStrategy>("strategy", Self::VT_STRATEGY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_data_node_id", Self::VT_TARGET_DATA_NODE_ID, false)?
     .visit_field::<RollbackStrategy>("rollback", Self::VT_ROLLBACK, false)?
     .finish();
    Ok(())
  }
}
pub struct OptimisticConfigArgs<'a> {
    pub strategy: OptimisticStrategy,
    pub target_data_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub rollback: RollbackStrategy,
}
impl<'a> Default for OptimisticConfigArgs<'a> {
  #[inline]
  fn default() -> Self {
    OptimisticConfigArgs {
      strategy: OptimisticStrategy::None,
      target_data_node_id: None,
      rollback: RollbackStrategy::Revert,
    }
  }
}

pub struct OptimisticConfigBuilder<'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> OptimisticConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_strategy(&mut self, strategy: OptimisticStrategy) {
    self.fbb_.push_slot::<OptimisticStrategy>(OptimisticConfig::VT_STRATEGY, strategy, OptimisticStrategy::None);
  }
  #[inline]
  pub fn add_target_data_node_id(&mut self, target_data_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OptimisticConfig::VT_TARGET_DATA_NODE_ID, target_data_node_id);
  }
  #[inline]
  pub fn add_rollback(&mut self, rollback: RollbackStrategy) {
    self.fbb_.push_slot::<RollbackStrategy>(OptimisticConfig::VT_ROLLBACK, rollback, RollbackStrategy::Revert);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> OptimisticConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    OptimisticConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<OptimisticConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ErrorHandling<'a> {
  pub const VT_RETRY: flatbuffers::VOffsetT = 4;
  pub const VT_FALLBACK: flatbuffers::VOffsetT = 6;
  pub const VT_REDIRECT_PATH: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ErrorHandling { _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 ErrorHandlingArgs<'args>
  ) -> flatbuffers::WIPOffset<ErrorHandling<'bldr>> {
    let mut builder = ErrorHandlingBuilder::new(_fbb);
    if let Some(x) = args.redirect_path { builder.add_redirect_path(x); }
    if let Some(x) = args.retry { builder.add_retry(x); }
    builder.add_fallback(args.fallback);
    builder.finish()
  }


  #[inline]
  pub fn retry(&self) -> Option<RetryConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RetryConfig>>(ErrorHandling::VT_RETRY, None)}
  }
  #[inline]
  pub fn fallback(&self) -> ErrorFallback {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ErrorFallback>(ErrorHandling::VT_FALLBACK, Some(ErrorFallback::ShowToast)).unwrap()}
  }
  /// Route to redirect to on error (for Redirect fallback).
  #[inline]
  pub fn redirect_path(&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>>(ErrorHandling::VT_REDIRECT_PATH, None)}
  }
}

impl flatbuffers::Verifiable for ErrorHandling<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<RetryConfig>>("retry", Self::VT_RETRY, false)?
     .visit_field::<ErrorFallback>("fallback", Self::VT_FALLBACK, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("redirect_path", Self::VT_REDIRECT_PATH, false)?
     .finish();
    Ok(())
  }
}
pub struct ErrorHandlingArgs<'a> {
    pub retry: Option<flatbuffers::WIPOffset<RetryConfig<'a>>>,
    pub fallback: ErrorFallback,
    pub redirect_path: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ErrorHandlingArgs<'a> {
  #[inline]
  fn default() -> Self {
    ErrorHandlingArgs {
      retry: None,
      fallback: ErrorFallback::ShowToast,
      redirect_path: None,
    }
  }
}

pub struct ErrorHandlingBuilder<'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> ErrorHandlingBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_retry(&mut self, retry: flatbuffers::WIPOffset<RetryConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RetryConfig>>(ErrorHandling::VT_RETRY, retry);
  }
  #[inline]
  pub fn add_fallback(&mut self, fallback: ErrorFallback) {
    self.fbb_.push_slot::<ErrorFallback>(ErrorHandling::VT_FALLBACK, fallback, ErrorFallback::ShowToast);
  }
  #[inline]
  pub fn add_redirect_path(&mut self, redirect_path: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ErrorHandling::VT_REDIRECT_PATH, redirect_path);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ErrorHandlingBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ErrorHandlingBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ErrorHandling<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ActionNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_SOURCE: flatbuffers::VOffsetT = 8;
  pub const VT_METHOD: flatbuffers::VOffsetT = 10;
  pub const VT_INPUT_TYPE: flatbuffers::VOffsetT = 12;
  pub const VT_OUTPUT_TYPE: flatbuffers::VOffsetT = 14;
  pub const VT_OPTIMISTIC: flatbuffers::VOffsetT = 16;
  pub const VT_INVALIDATES: flatbuffers::VOffsetT = 18;
  pub const VT_INVALIDATE_TAGS: flatbuffers::VOffsetT = 20;
  pub const VT_ERROR_HANDLING: flatbuffers::VOffsetT = 22;
  pub const VT_AUTH_REQUIRED: flatbuffers::VOffsetT = 24;
  pub const VT_REQUIRED_ROLES: flatbuffers::VOffsetT = 26;
  pub const VT_CSRF_PROTECTED: flatbuffers::VOffsetT = 28;
  pub const VT_IDEMPOTENT: flatbuffers::VOffsetT = 30;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ActionNode { _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 ActionNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<ActionNode<'bldr>> {
    let mut builder = ActionNodeBuilder::new(_fbb);
    if let Some(x) = args.required_roles { builder.add_required_roles(x); }
    if let Some(x) = args.error_handling { builder.add_error_handling(x); }
    if let Some(x) = args.invalidate_tags { builder.add_invalidate_tags(x); }
    if let Some(x) = args.invalidates { builder.add_invalidates(x); }
    if let Some(x) = args.optimistic { builder.add_optimistic(x); }
    if let Some(x) = args.output_type { builder.add_output_type(x); }
    if let Some(x) = args.input_type { builder.add_input_type(x); }
    if let Some(x) = args.source { builder.add_source(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_idempotent(args.idempotent);
    builder.add_csrf_protected(args.csrf_protected);
    builder.add_auth_required(args.auth_required);
    builder.add_method(args.method);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ActionNode::VT_NODE_ID, None).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>>(ActionNode::VT_NAME, None)}
  }
  /// Endpoint configuration (reuses DataSource from state.fbs).
  #[inline]
  pub fn source(&self) -> DataSource<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<DataSource>>(ActionNode::VT_SOURCE, None).unwrap()}
  }
  #[inline]
  pub fn method(&self) -> HttpMethod {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<HttpMethod>(ActionNode::VT_METHOD, Some(HttpMethod::POST)).unwrap()}
  }
  /// Input/output type hints for the compiler.
  #[inline]
  pub fn input_type(&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>>(ActionNode::VT_INPUT_TYPE, None)}
  }
  #[inline]
  pub fn output_type(&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>>(ActionNode::VT_OUTPUT_TYPE, None)}
  }
  /// Optimistic update behavior.
  #[inline]
  pub fn optimistic(&self) -> Option<OptimisticConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<OptimisticConfig>>(ActionNode::VT_OPTIMISTIC, None)}
  }
  /// DataNode IDs to refetch after successful mutation.
  #[inline]
  pub fn invalidates(&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>>>>(ActionNode::VT_INVALIDATES, None)}
  }
  /// Cache tags to invalidate (matches DataNode.cache_tags).
  #[inline]
  pub fn invalidate_tags(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>(ActionNode::VT_INVALIDATE_TAGS, None)}
  }
  /// Error handling.
  #[inline]
  pub fn error_handling(&self) -> Option<ErrorHandling<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ErrorHandling>>(ActionNode::VT_ERROR_HANDLING, None)}
  }
  /// Auth requirements.
  #[inline]
  pub fn auth_required(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ActionNode::VT_AUTH_REQUIRED, Some(false)).unwrap()}
  }
  #[inline]
  pub fn required_roles(&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>>>>(ActionNode::VT_REQUIRED_ROLES, None)}
  }
  /// Security.
  #[inline]
  pub fn csrf_protected(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ActionNode::VT_CSRF_PROTECTED, Some(true)).unwrap()}
  }
  #[inline]
  pub fn idempotent(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ActionNode::VT_IDEMPOTENT, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for ActionNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<DataSource>>("source", Self::VT_SOURCE, true)?
     .visit_field::<HttpMethod>("method", Self::VT_METHOD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("input_type", Self::VT_INPUT_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("output_type", Self::VT_OUTPUT_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<OptimisticConfig>>("optimistic", Self::VT_OPTIMISTIC, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("invalidates", Self::VT_INVALIDATES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("invalidate_tags", Self::VT_INVALIDATE_TAGS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ErrorHandling>>("error_handling", Self::VT_ERROR_HANDLING, false)?
     .visit_field::<bool>("auth_required", Self::VT_AUTH_REQUIRED, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("required_roles", Self::VT_REQUIRED_ROLES, false)?
     .visit_field::<bool>("csrf_protected", Self::VT_CSRF_PROTECTED, false)?
     .visit_field::<bool>("idempotent", Self::VT_IDEMPOTENT, false)?
     .finish();
    Ok(())
  }
}
pub struct ActionNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source: Option<flatbuffers::WIPOffset<DataSource<'a>>>,
    pub method: HttpMethod,
    pub input_type: Option<flatbuffers::WIPOffset<&'a str>>,
    pub output_type: Option<flatbuffers::WIPOffset<&'a str>>,
    pub optimistic: Option<flatbuffers::WIPOffset<OptimisticConfig<'a>>>,
    pub invalidates: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub invalidate_tags: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub error_handling: Option<flatbuffers::WIPOffset<ErrorHandling<'a>>>,
    pub auth_required: bool,
    pub required_roles: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub csrf_protected: bool,
    pub idempotent: bool,
}
impl<'a> Default for ActionNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    ActionNodeArgs {
      node_id: None, // required field
      name: None,
      source: None, // required field
      method: HttpMethod::POST,
      input_type: None,
      output_type: None,
      optimistic: None,
      invalidates: None,
      invalidate_tags: None,
      error_handling: None,
      auth_required: false,
      required_roles: None,
      csrf_protected: true,
      idempotent: false,
    }
  }
}

pub struct ActionNodeBuilder<'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> ActionNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_source(&mut self, source: flatbuffers::WIPOffset<DataSource<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<DataSource>>(ActionNode::VT_SOURCE, source);
  }
  #[inline]
  pub fn add_method(&mut self, method: HttpMethod) {
    self.fbb_.push_slot::<HttpMethod>(ActionNode::VT_METHOD, method, HttpMethod::POST);
  }
  #[inline]
  pub fn add_input_type(&mut self, input_type: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_INPUT_TYPE, input_type);
  }
  #[inline]
  pub fn add_output_type(&mut self, output_type: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_OUTPUT_TYPE, output_type);
  }
  #[inline]
  pub fn add_optimistic(&mut self, optimistic: flatbuffers::WIPOffset<OptimisticConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<OptimisticConfig>>(ActionNode::VT_OPTIMISTIC, optimistic);
  }
  #[inline]
  pub fn add_invalidates(&mut self, invalidates: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_INVALIDATES, invalidates);
  }
  #[inline]
  pub fn add_invalidate_tags(&mut self, invalidate_tags: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_INVALIDATE_TAGS, invalidate_tags);
  }
  #[inline]
  pub fn add_error_handling(&mut self, error_handling: flatbuffers::WIPOffset<ErrorHandling<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ErrorHandling>>(ActionNode::VT_ERROR_HANDLING, error_handling);
  }
  #[inline]
  pub fn add_auth_required(&mut self, auth_required: bool) {
    self.fbb_.push_slot::<bool>(ActionNode::VT_AUTH_REQUIRED, auth_required, false);
  }
  #[inline]
  pub fn add_required_roles(&mut self, required_roles: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ActionNode::VT_REQUIRED_ROLES, required_roles);
  }
  #[inline]
  pub fn add_csrf_protected(&mut self, csrf_protected: bool) {
    self.fbb_.push_slot::<bool>(ActionNode::VT_CSRF_PROTECTED, csrf_protected, true);
  }
  #[inline]
  pub fn add_idempotent(&mut self, idempotent: bool) {
    self.fbb_.push_slot::<bool>(ActionNode::VT_IDEMPOTENT, idempotent, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ActionNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ActionNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ActionNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ActionNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ActionNode::VT_SOURCE,"source");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ActionNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ActionNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("source", &self.source());
      ds.field("method", &self.method());
      ds.field("input_type", &self.input_type());
      ds.field("output_type", &self.output_type());
      ds.field("optimistic", &self.optimistic());
      ds.field("invalidates", &self.invalidates());
      ds.field("invalidate_tags", &self.invalidate_tags());
      ds.field("error_handling", &self.error_handling());
      ds.field("auth_required", &self.auth_required());
      ds.field("required_roles", &self.required_roles());
      ds.field("csrf_protected", &self.csrf_protected());
      ds.field("idempotent", &self.idempotent());
      ds.finish()
  }
}
pub enum ConnectionConfigOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ConnectionConfig<'a> {
  pub const VT_RECONNECT: flatbuffers::VOffsetT = 4;
  pub const VT_RECONNECT_INTERVAL_MS: flatbuffers::VOffsetT = 6;
  pub const VT_MAX_RETRIES: flatbuffers::VOffsetT = 8;
  pub const VT_HEARTBEAT_INTERVAL_MS: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ConnectionConfig { _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 ConnectionConfigArgs
  ) -> flatbuffers::WIPOffset<ConnectionConfig<'bldr>> {
    let mut builder = ConnectionConfigBuilder::new(_fbb);
    builder.add_heartbeat_interval_ms(args.heartbeat_interval_ms);
    builder.add_max_retries(args.max_retries);
    builder.add_reconnect_interval_ms(args.reconnect_interval_ms);
    builder.add_reconnect(args.reconnect);
    builder.finish()
  }


  #[inline]
  pub fn reconnect(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ConnectionConfig::VT_RECONNECT, Some(true)).unwrap()}
  }
  #[inline]
  pub fn reconnect_interval_ms(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(ConnectionConfig::VT_RECONNECT_INTERVAL_MS, Some(3000)).unwrap()}
  }
  #[inline]
  pub fn max_retries(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(ConnectionConfig::VT_MAX_RETRIES, Some(10)).unwrap()}
  }
  #[inline]
  pub fn heartbeat_interval_ms(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(ConnectionConfig::VT_HEARTBEAT_INTERVAL_MS, Some(30000)).unwrap()}
  }
}

impl flatbuffers::Verifiable for ConnectionConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<bool>("reconnect", Self::VT_RECONNECT, false)?
     .visit_field::<u32>("reconnect_interval_ms", Self::VT_RECONNECT_INTERVAL_MS, false)?
     .visit_field::<i32>("max_retries", Self::VT_MAX_RETRIES, false)?
     .visit_field::<u32>("heartbeat_interval_ms", Self::VT_HEARTBEAT_INTERVAL_MS, false)?
     .finish();
    Ok(())
  }
}
pub struct ConnectionConfigArgs {
    pub reconnect: bool,
    pub reconnect_interval_ms: u32,
    pub max_retries: i32,
    pub heartbeat_interval_ms: u32,
}
impl<'a> Default for ConnectionConfigArgs {
  #[inline]
  fn default() -> Self {
    ConnectionConfigArgs {
      reconnect: true,
      reconnect_interval_ms: 3000,
      max_retries: 10,
      heartbeat_interval_ms: 30000,
    }
  }
}

pub struct ConnectionConfigBuilder<'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> ConnectionConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_reconnect(&mut self, reconnect: bool) {
    self.fbb_.push_slot::<bool>(ConnectionConfig::VT_RECONNECT, reconnect, true);
  }
  #[inline]
  pub fn add_reconnect_interval_ms(&mut self, reconnect_interval_ms: u32) {
    self.fbb_.push_slot::<u32>(ConnectionConfig::VT_RECONNECT_INTERVAL_MS, reconnect_interval_ms, 3000);
  }
  #[inline]
  pub fn add_max_retries(&mut self, max_retries: i32) {
    self.fbb_.push_slot::<i32>(ConnectionConfig::VT_MAX_RETRIES, max_retries, 10);
  }
  #[inline]
  pub fn add_heartbeat_interval_ms(&mut self, heartbeat_interval_ms: u32) {
    self.fbb_.push_slot::<u32>(ConnectionConfig::VT_HEARTBEAT_INTERVAL_MS, heartbeat_interval_ms, 30000);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ConnectionConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ConnectionConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ConnectionConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SubscriptionNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_SOURCE: flatbuffers::VOffsetT = 8;
  pub const VT_TRANSPORT: flatbuffers::VOffsetT = 10;
  pub const VT_CHANNEL: flatbuffers::VOffsetT = 12;
  pub const VT_FILTER: flatbuffers::VOffsetT = 14;
  pub const VT_UPDATE_STRATEGY: flatbuffers::VOffsetT = 16;
  pub const VT_TARGET_DATA_NODE_ID: flatbuffers::VOffsetT = 18;
  pub const VT_CONNECTION: flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SubscriptionNode { _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 SubscriptionNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<SubscriptionNode<'bldr>> {
    let mut builder = SubscriptionNodeBuilder::new(_fbb);
    if let Some(x) = args.connection { builder.add_connection(x); }
    if let Some(x) = args.target_data_node_id { builder.add_target_data_node_id(x); }
    if let Some(x) = args.filter { builder.add_filter(x); }
    if let Some(x) = args.channel { builder.add_channel(x); }
    if let Some(x) = args.source { builder.add_source(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_update_strategy(args.update_strategy);
    builder.add_transport(args.transport);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(SubscriptionNode::VT_NODE_ID, None).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>>(SubscriptionNode::VT_NAME, None)}
  }
  #[inline]
  pub fn source(&self) -> DataSource<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<DataSource>>(SubscriptionNode::VT_SOURCE, None).unwrap()}
  }
  #[inline]
  pub fn transport(&self) -> SubscriptionTransport {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<SubscriptionTransport>(SubscriptionNode::VT_TRANSPORT, Some(SubscriptionTransport::WebSocket)).unwrap()}
  }
  /// Channel/topic/table to subscribe to.
  #[inline]
  pub fn channel(&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>>(SubscriptionNode::VT_CHANNEL, None)}
  }
  /// Filter expression for the subscription.
  #[inline]
  pub fn filter(&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>>(SubscriptionNode::VT_FILTER, None)}
  }
  /// How to apply incoming updates to the target DataNode.
  #[inline]
  pub fn update_strategy(&self) -> UpdateStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<UpdateStrategy>(SubscriptionNode::VT_UPDATE_STRATEGY, Some(UpdateStrategy::Replace)).unwrap()}
  }
  /// Which DataNode to keep updated.
  #[inline]
  pub fn target_data_node_id(&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>>(SubscriptionNode::VT_TARGET_DATA_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn connection(&self) -> Option<ConnectionConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ConnectionConfig>>(SubscriptionNode::VT_CONNECTION, None)}
  }
}

impl flatbuffers::Verifiable for SubscriptionNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<DataSource>>("source", Self::VT_SOURCE, true)?
     .visit_field::<SubscriptionTransport>("transport", Self::VT_TRANSPORT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("channel", Self::VT_CHANNEL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("filter", Self::VT_FILTER, false)?
     .visit_field::<UpdateStrategy>("update_strategy", Self::VT_UPDATE_STRATEGY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_data_node_id", Self::VT_TARGET_DATA_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ConnectionConfig>>("connection", Self::VT_CONNECTION, false)?
     .finish();
    Ok(())
  }
}
pub struct SubscriptionNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source: Option<flatbuffers::WIPOffset<DataSource<'a>>>,
    pub transport: SubscriptionTransport,
    pub channel: Option<flatbuffers::WIPOffset<&'a str>>,
    pub filter: Option<flatbuffers::WIPOffset<&'a str>>,
    pub update_strategy: UpdateStrategy,
    pub target_data_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub connection: Option<flatbuffers::WIPOffset<ConnectionConfig<'a>>>,
}
impl<'a> Default for SubscriptionNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    SubscriptionNodeArgs {
      node_id: None, // required field
      name: None,
      source: None, // required field
      transport: SubscriptionTransport::WebSocket,
      channel: None,
      filter: None,
      update_strategy: UpdateStrategy::Replace,
      target_data_node_id: None, // required field
      connection: None,
    }
  }
}

pub struct SubscriptionNodeBuilder<'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> SubscriptionNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SubscriptionNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SubscriptionNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_source(&mut self, source: flatbuffers::WIPOffset<DataSource<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<DataSource>>(SubscriptionNode::VT_SOURCE, source);
  }
  #[inline]
  pub fn add_transport(&mut self, transport: SubscriptionTransport) {
    self.fbb_.push_slot::<SubscriptionTransport>(SubscriptionNode::VT_TRANSPORT, transport, SubscriptionTransport::WebSocket);
  }
  #[inline]
  pub fn add_channel(&mut self, channel: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SubscriptionNode::VT_CHANNEL, channel);
  }
  #[inline]
  pub fn add_filter(&mut self, filter: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SubscriptionNode::VT_FILTER, filter);
  }
  #[inline]
  pub fn add_update_strategy(&mut self, update_strategy: UpdateStrategy) {
    self.fbb_.push_slot::<UpdateStrategy>(SubscriptionNode::VT_UPDATE_STRATEGY, update_strategy, UpdateStrategy::Replace);
  }
  #[inline]
  pub fn add_target_data_node_id(&mut self, target_data_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SubscriptionNode::VT_TARGET_DATA_NODE_ID, target_data_node_id);
  }
  #[inline]
  pub fn add_connection(&mut self, connection: flatbuffers::WIPOffset<ConnectionConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ConnectionConfig>>(SubscriptionNode::VT_CONNECTION, connection);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SubscriptionNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SubscriptionNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SubscriptionNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SubscriptionNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, SubscriptionNode::VT_SOURCE,"source");
    self.fbb_.required(o, SubscriptionNode::VT_TARGET_DATA_NODE_ID,"target_data_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for SubscriptionNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("SubscriptionNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("source", &self.source());
      ds.field("transport", &self.transport());
      ds.field("channel", &self.channel());
      ds.field("filter", &self.filter());
      ds.field("update_strategy", &self.update_strategy());
      ds.field("target_data_node_id", &self.target_data_node_id());
      ds.field("connection", &self.connection());
      ds.finish()
  }
}
pub enum AuthContextNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> AuthContextNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_PROVIDER: flatbuffers::VOffsetT = 8;
  pub const VT_SESSION_STRATEGY: flatbuffers::VOffsetT = 10;
  pub const VT_USER_TYPE: flatbuffers::VOffsetT = 12;
  pub const VT_ROLE_FIELD: flatbuffers::VOffsetT = 14;
  pub const VT_LOGIN_ACTION_ID: flatbuffers::VOffsetT = 16;
  pub const VT_LOGOUT_ACTION_ID: flatbuffers::VOffsetT = 18;
  pub const VT_REFRESH_ACTION_ID: flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AuthContextNode { _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 AuthContextNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<AuthContextNode<'bldr>> {
    let mut builder = AuthContextNodeBuilder::new(_fbb);
    if let Some(x) = args.refresh_action_id { builder.add_refresh_action_id(x); }
    if let Some(x) = args.logout_action_id { builder.add_logout_action_id(x); }
    if let Some(x) = args.login_action_id { builder.add_login_action_id(x); }
    if let Some(x) = args.role_field { builder.add_role_field(x); }
    if let Some(x) = args.user_type { builder.add_user_type(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_session_strategy(args.session_strategy);
    builder.add_provider(args.provider);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(AuthContextNode::VT_NODE_ID, None).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>>(AuthContextNode::VT_NAME, None)}
  }
  #[inline]
  pub fn provider(&self) -> AuthProvider {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<AuthProvider>(AuthContextNode::VT_PROVIDER, Some(AuthProvider::Auth0)).unwrap()}
  }
  #[inline]
  pub fn session_strategy(&self) -> SessionStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<SessionStrategy>(AuthContextNode::VT_SESSION_STRATEGY, Some(SessionStrategy::JwtCookie)).unwrap()}
  }
  /// Type hint for the user object shape.
  #[inline]
  pub fn user_type(&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>>(AuthContextNode::VT_USER_TYPE, None)}
  }
  /// Field path for roles in the user object.
  #[inline]
  pub fn role_field(&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>>(AuthContextNode::VT_ROLE_FIELD, None)}
  }
  /// Action references for auth operations.
  #[inline]
  pub fn login_action_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(AuthContextNode::VT_LOGIN_ACTION_ID, None)}
  }
  #[inline]
  pub fn logout_action_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(AuthContextNode::VT_LOGOUT_ACTION_ID, None)}
  }
  #[inline]
  pub fn refresh_action_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(AuthContextNode::VT_REFRESH_ACTION_ID, None)}
  }
}

impl flatbuffers::Verifiable for AuthContextNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<AuthProvider>("provider", Self::VT_PROVIDER, false)?
     .visit_field::<SessionStrategy>("session_strategy", Self::VT_SESSION_STRATEGY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("user_type", Self::VT_USER_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("role_field", Self::VT_ROLE_FIELD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("login_action_id", Self::VT_LOGIN_ACTION_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("logout_action_id", Self::VT_LOGOUT_ACTION_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("refresh_action_id", Self::VT_REFRESH_ACTION_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct AuthContextNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub provider: AuthProvider,
    pub session_strategy: SessionStrategy,
    pub user_type: Option<flatbuffers::WIPOffset<&'a str>>,
    pub role_field: Option<flatbuffers::WIPOffset<&'a str>>,
    pub login_action_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub logout_action_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub refresh_action_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AuthContextNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    AuthContextNodeArgs {
      node_id: None, // required field
      name: None,
      provider: AuthProvider::Auth0,
      session_strategy: SessionStrategy::JwtCookie,
      user_type: None,
      role_field: None,
      login_action_id: None,
      logout_action_id: None,
      refresh_action_id: None,
    }
  }
}

pub struct AuthContextNodeBuilder<'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> AuthContextNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_provider(&mut self, provider: AuthProvider) {
    self.fbb_.push_slot::<AuthProvider>(AuthContextNode::VT_PROVIDER, provider, AuthProvider::Auth0);
  }
  #[inline]
  pub fn add_session_strategy(&mut self, session_strategy: SessionStrategy) {
    self.fbb_.push_slot::<SessionStrategy>(AuthContextNode::VT_SESSION_STRATEGY, session_strategy, SessionStrategy::JwtCookie);
  }
  #[inline]
  pub fn add_user_type(&mut self, user_type: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_USER_TYPE, user_type);
  }
  #[inline]
  pub fn add_role_field(&mut self, role_field: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_ROLE_FIELD, role_field);
  }
  #[inline]
  pub fn add_login_action_id(&mut self, login_action_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_LOGIN_ACTION_ID, login_action_id);
  }
  #[inline]
  pub fn add_logout_action_id(&mut self, logout_action_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_LOGOUT_ACTION_ID, logout_action_id);
  }
  #[inline]
  pub fn add_refresh_action_id(&mut self, refresh_action_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AuthContextNode::VT_REFRESH_ACTION_ID, refresh_action_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AuthContextNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AuthContextNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AuthContextNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AuthContextNode::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for AuthContextNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("AuthContextNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("provider", &self.provider());
      ds.field("session_strategy", &self.session_strategy());
      ds.field("user_type", &self.user_type());
      ds.field("role_field", &self.role_field());
      ds.field("login_action_id", &self.login_action_id());
      ds.field("logout_action_id", &self.logout_action_id());
      ds.field("refresh_action_id", &self.refresh_action_id());
      ds.finish()
  }
}
pub enum ContentSourceOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ContentSource<'a> {
  pub const VT_PROVIDER: flatbuffers::VOffsetT = 4;
  pub const VT_ENDPOINT: flatbuffers::VOffsetT = 6;
  pub const VT_AUTH_METHOD: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ContentSource { _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 ContentSourceArgs<'args>
  ) -> flatbuffers::WIPOffset<ContentSource<'bldr>> {
    let mut builder = ContentSourceBuilder::new(_fbb);
    if let Some(x) = args.auth_method { builder.add_auth_method(x); }
    if let Some(x) = args.endpoint { builder.add_endpoint(x); }
    if let Some(x) = args.provider { builder.add_provider(x); }
    builder.finish()
  }


  /// CMS provider.
  #[inline]
  pub fn provider(&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>>(ContentSource::VT_PROVIDER, None)}
  }
  /// API endpoint or base URL.
  #[inline]
  pub fn endpoint(&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>>(ContentSource::VT_ENDPOINT, None)}
  }
  /// Authentication method for the CMS API.
  #[inline]
  pub fn auth_method(&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>>(ContentSource::VT_AUTH_METHOD, None)}
  }
}

impl flatbuffers::Verifiable for ContentSource<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("provider", Self::VT_PROVIDER, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("endpoint", Self::VT_ENDPOINT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("auth_method", Self::VT_AUTH_METHOD, false)?
     .finish();
    Ok(())
  }
}
pub struct ContentSourceArgs<'a> {
    pub provider: Option<flatbuffers::WIPOffset<&'a str>>,
    pub endpoint: Option<flatbuffers::WIPOffset<&'a str>>,
    pub auth_method: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ContentSourceArgs<'a> {
  #[inline]
  fn default() -> Self {
    ContentSourceArgs {
      provider: None,
      endpoint: None,
      auth_method: None,
    }
  }
}

pub struct ContentSourceBuilder<'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> ContentSourceBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_provider(&mut self, provider: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSource::VT_PROVIDER, provider);
  }
  #[inline]
  pub fn add_endpoint(&mut self, endpoint: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSource::VT_ENDPOINT, endpoint);
  }
  #[inline]
  pub fn add_auth_method(&mut self, auth_method: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSource::VT_AUTH_METHOD, auth_method);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ContentSourceBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ContentSourceBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ContentSource<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> ContentSlot<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CONTENT_KEY: flatbuffers::VOffsetT = 6;
  pub const VT_SOURCE: flatbuffers::VOffsetT = 8;
  pub const VT_FALLBACK: flatbuffers::VOffsetT = 10;
  pub const VT_CACHE_STRATEGY: flatbuffers::VOffsetT = 12;
  pub const VT_CONTENT_TYPE: flatbuffers::VOffsetT = 14;
  pub const VT_LOCALE: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ContentSlot { _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 ContentSlotArgs<'args>
  ) -> flatbuffers::WIPOffset<ContentSlot<'bldr>> {
    let mut builder = ContentSlotBuilder::new(_fbb);
    if let Some(x) = args.locale { builder.add_locale(x); }
    if let Some(x) = args.fallback { builder.add_fallback(x); }
    if let Some(x) = args.source { builder.add_source(x); }
    if let Some(x) = args.content_key { builder.add_content_key(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_content_type(args.content_type);
    builder.add_cache_strategy(args.cache_strategy);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ContentSlot::VT_NODE_ID, None).unwrap()}
  }
  /// Content key in the CMS (entry ID or content path).
  #[inline]
  pub fn content_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>>(ContentSlot::VT_CONTENT_KEY, None).unwrap()}
  }
  #[inline]
  pub fn source(&self) -> Option<ContentSource<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ContentSource>>(ContentSlot::VT_SOURCE, None)}
  }
  /// Fallback content if CMS fetch fails.
  #[inline]
  pub fn fallback(&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>>(ContentSlot::VT_FALLBACK, None)}
  }
  #[inline]
  pub fn cache_strategy(&self) -> ContentCacheStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ContentCacheStrategy>(ContentSlot::VT_CACHE_STRATEGY, Some(ContentCacheStrategy::Static)).unwrap()}
  }
  #[inline]
  pub fn content_type(&self) -> ContentType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ContentType>(ContentSlot::VT_CONTENT_TYPE, Some(ContentType::Text)).unwrap()}
  }
  /// Locale for this content slot (i18n).
  #[inline]
  pub fn locale(&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>>(ContentSlot::VT_LOCALE, None)}
  }
}

impl flatbuffers::Verifiable for ContentSlot<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("content_key", Self::VT_CONTENT_KEY, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ContentSource>>("source", Self::VT_SOURCE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("fallback", Self::VT_FALLBACK, false)?
     .visit_field::<ContentCacheStrategy>("cache_strategy", Self::VT_CACHE_STRATEGY, false)?
     .visit_field::<ContentType>("content_type", Self::VT_CONTENT_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("locale", Self::VT_LOCALE, false)?
     .finish();
    Ok(())
  }
}
pub struct ContentSlotArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub content_key: Option<flatbuffers::WIPOffset<&'a str>>,
    pub source: Option<flatbuffers::WIPOffset<ContentSource<'a>>>,
    pub fallback: Option<flatbuffers::WIPOffset<&'a str>>,
    pub cache_strategy: ContentCacheStrategy,
    pub content_type: ContentType,
    pub locale: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ContentSlotArgs<'a> {
  #[inline]
  fn default() -> Self {
    ContentSlotArgs {
      node_id: None, // required field
      content_key: None, // required field
      source: None,
      fallback: None,
      cache_strategy: ContentCacheStrategy::Static,
      content_type: ContentType::Text,
      locale: None,
    }
  }
}

pub struct ContentSlotBuilder<'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> ContentSlotBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSlot::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_content_key(&mut self, content_key: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSlot::VT_CONTENT_KEY, content_key);
  }
  #[inline]
  pub fn add_source(&mut self, source: flatbuffers::WIPOffset<ContentSource<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ContentSource>>(ContentSlot::VT_SOURCE, source);
  }
  #[inline]
  pub fn add_fallback(&mut self, fallback: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSlot::VT_FALLBACK, fallback);
  }
  #[inline]
  pub fn add_cache_strategy(&mut self, cache_strategy: ContentCacheStrategy) {
    self.fbb_.push_slot::<ContentCacheStrategy>(ContentSlot::VT_CACHE_STRATEGY, cache_strategy, ContentCacheStrategy::Static);
  }
  #[inline]
  pub fn add_content_type(&mut self, content_type: ContentType) {
    self.fbb_.push_slot::<ContentType>(ContentSlot::VT_CONTENT_TYPE, content_type, ContentType::Text);
  }
  #[inline]
  pub fn add_locale(&mut self, locale: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ContentSlot::VT_LOCALE, locale);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ContentSlotBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ContentSlotBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ContentSlot<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ContentSlot::VT_NODE_ID,"node_id");
    self.fbb_.required(o, ContentSlot::VT_CONTENT_KEY,"content_key");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RichTextSpan<'a> {
  pub const VT_TEXT: flatbuffers::VOffsetT = 4;
  pub const VT_MARKS: flatbuffers::VOffsetT = 6;
  pub const VT_LINK_URL: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RichTextSpan { _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 RichTextSpanArgs<'args>
  ) -> flatbuffers::WIPOffset<RichTextSpan<'bldr>> {
    let mut builder = RichTextSpanBuilder::new(_fbb);
    if let Some(x) = args.link_url { builder.add_link_url(x); }
    if let Some(x) = args.marks { builder.add_marks(x); }
    if let Some(x) = args.text { builder.add_text(x); }
    builder.finish()
  }


  #[inline]
  pub fn text(&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>>(RichTextSpan::VT_TEXT, None).unwrap()}
  }
  #[inline]
  pub fn marks(&self) -> Option<flatbuffers::Vector<'a, RichTextMark>> {
    // 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, RichTextMark>>>(RichTextSpan::VT_MARKS, None)}
  }
  /// If this span is a link, the URL.
  #[inline]
  pub fn link_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>>(RichTextSpan::VT_LINK_URL, None)}
  }
}

impl flatbuffers::Verifiable for RichTextSpan<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("text", Self::VT_TEXT, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, RichTextMark>>>("marks", Self::VT_MARKS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("link_url", Self::VT_LINK_URL, false)?
     .finish();
    Ok(())
  }
}
pub struct RichTextSpanArgs<'a> {
    pub text: Option<flatbuffers::WIPOffset<&'a str>>,
    pub marks: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, RichTextMark>>>,
    pub link_url: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for RichTextSpanArgs<'a> {
  #[inline]
  fn default() -> Self {
    RichTextSpanArgs {
      text: None, // required field
      marks: None,
      link_url: None,
    }
  }
}

pub struct RichTextSpanBuilder<'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> RichTextSpanBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_text(&mut self, text: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextSpan::VT_TEXT, text);
  }
  #[inline]
  pub fn add_marks(&mut self, marks: flatbuffers::WIPOffset<flatbuffers::Vector<'b , RichTextMark>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextSpan::VT_MARKS, marks);
  }
  #[inline]
  pub fn add_link_url(&mut self, link_url: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextSpan::VT_LINK_URL, link_url);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RichTextSpanBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RichTextSpanBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RichTextSpan<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RichTextSpan::VT_TEXT,"text");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> RichTextBlock<'a> {
  pub const VT_BLOCK_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_LEVEL: flatbuffers::VOffsetT = 6;
  pub const VT_CHILDREN: flatbuffers::VOffsetT = 8;
  pub const VT_MEDIA_SRC: flatbuffers::VOffsetT = 10;
  pub const VT_MEDIA_ALT: flatbuffers::VOffsetT = 12;
  pub const VT_CODE_LANGUAGE: flatbuffers::VOffsetT = 14;
  pub const VT_ROWS: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RichTextBlock { _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 RichTextBlockArgs<'args>
  ) -> flatbuffers::WIPOffset<RichTextBlock<'bldr>> {
    let mut builder = RichTextBlockBuilder::new(_fbb);
    if let Some(x) = args.rows { builder.add_rows(x); }
    if let Some(x) = args.code_language { builder.add_code_language(x); }
    if let Some(x) = args.media_alt { builder.add_media_alt(x); }
    if let Some(x) = args.media_src { builder.add_media_src(x); }
    if let Some(x) = args.children { builder.add_children(x); }
    builder.add_level(args.level);
    builder.add_block_type(args.block_type);
    builder.finish()
  }


  #[inline]
  pub fn block_type(&self) -> RichTextBlockType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<RichTextBlockType>(RichTextBlock::VT_BLOCK_TYPE, Some(RichTextBlockType::Paragraph)).unwrap()}
  }
  /// Heading level (1-6), list depth, etc.
  #[inline]
  pub fn level(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(RichTextBlock::VT_LEVEL, Some(0)).unwrap()}
  }
  /// Inline text content.
  #[inline]
  pub fn children(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextSpan<'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<RichTextSpan>>>>(RichTextBlock::VT_CHILDREN, None)}
  }
  /// For Image blocks — embedded media.
  #[inline]
  pub fn media_src(&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>>(RichTextBlock::VT_MEDIA_SRC, None)}
  }
  #[inline]
  pub fn media_alt(&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>>(RichTextBlock::VT_MEDIA_ALT, None)}
  }
  /// For CodeBlock — language hint.
  #[inline]
  pub fn code_language(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(RichTextBlock::VT_CODE_LANGUAGE, None)}
  }
  /// For Table — nested rows.
  #[inline]
  pub fn rows(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextBlock<'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<RichTextBlock>>>>(RichTextBlock::VT_ROWS, None)}
  }
}

impl flatbuffers::Verifiable for RichTextBlock<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<RichTextBlockType>("block_type", Self::VT_BLOCK_TYPE, false)?
     .visit_field::<i8>("level", Self::VT_LEVEL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RichTextSpan>>>>("children", Self::VT_CHILDREN, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("media_src", Self::VT_MEDIA_SRC, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("media_alt", Self::VT_MEDIA_ALT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("code_language", Self::VT_CODE_LANGUAGE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RichTextBlock>>>>("rows", Self::VT_ROWS, false)?
     .finish();
    Ok(())
  }
}
pub struct RichTextBlockArgs<'a> {
    pub block_type: RichTextBlockType,
    pub level: i8,
    pub children: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextSpan<'a>>>>>,
    pub media_src: Option<flatbuffers::WIPOffset<&'a str>>,
    pub media_alt: Option<flatbuffers::WIPOffset<&'a str>>,
    pub code_language: Option<flatbuffers::WIPOffset<&'a str>>,
    pub rows: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextBlock<'a>>>>>,
}
impl<'a> Default for RichTextBlockArgs<'a> {
  #[inline]
  fn default() -> Self {
    RichTextBlockArgs {
      block_type: RichTextBlockType::Paragraph,
      level: 0,
      children: None,
      media_src: None,
      media_alt: None,
      code_language: None,
      rows: None,
    }
  }
}

pub struct RichTextBlockBuilder<'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> RichTextBlockBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_block_type(&mut self, block_type: RichTextBlockType) {
    self.fbb_.push_slot::<RichTextBlockType>(RichTextBlock::VT_BLOCK_TYPE, block_type, RichTextBlockType::Paragraph);
  }
  #[inline]
  pub fn add_level(&mut self, level: i8) {
    self.fbb_.push_slot::<i8>(RichTextBlock::VT_LEVEL, level, 0);
  }
  #[inline]
  pub fn add_children(&mut self, children: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<RichTextSpan<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextBlock::VT_CHILDREN, children);
  }
  #[inline]
  pub fn add_media_src(&mut self, media_src: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextBlock::VT_MEDIA_SRC, media_src);
  }
  #[inline]
  pub fn add_media_alt(&mut self, media_alt: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextBlock::VT_MEDIA_ALT, media_alt);
  }
  #[inline]
  pub fn add_code_language(&mut self, code_language: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextBlock::VT_CODE_LANGUAGE, code_language);
  }
  #[inline]
  pub fn add_rows(&mut self, rows: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<RichTextBlock<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextBlock::VT_ROWS, rows);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RichTextBlockBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RichTextBlockBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RichTextBlock<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for RichTextBlock<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("RichTextBlock");
      ds.field("block_type", &self.block_type());
      ds.field("level", &self.level());
      ds.field("children", &self.children());
      ds.field("media_src", &self.media_src());
      ds.field("media_alt", &self.media_alt());
      ds.field("code_language", &self.code_language());
      ds.field("rows", &self.rows());
      ds.finish()
  }
}
pub enum RichTextNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> RichTextNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_BLOCKS: flatbuffers::VOffsetT = 6;
  pub const VT_CONTENT_SLOT: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RichTextNode { _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 RichTextNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<RichTextNode<'bldr>> {
    let mut builder = RichTextNodeBuilder::new(_fbb);
    if let Some(x) = args.content_slot { builder.add_content_slot(x); }
    if let Some(x) = args.blocks { builder.add_blocks(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(RichTextNode::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn blocks(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextBlock<'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<RichTextBlock>>>>(RichTextNode::VT_BLOCKS, None).unwrap()}
  }
  /// Content source (if from CMS).
  #[inline]
  pub fn content_slot(&self) -> Option<ContentSlot<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ContentSlot>>(RichTextNode::VT_CONTENT_SLOT, None)}
  }
}

impl flatbuffers::Verifiable for RichTextNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RichTextBlock>>>>("blocks", Self::VT_BLOCKS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ContentSlot>>("content_slot", Self::VT_CONTENT_SLOT, false)?
     .finish();
    Ok(())
  }
}
pub struct RichTextNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub blocks: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RichTextBlock<'a>>>>>,
    pub content_slot: Option<flatbuffers::WIPOffset<ContentSlot<'a>>>,
}
impl<'a> Default for RichTextNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    RichTextNodeArgs {
      node_id: None, // required field
      blocks: None, // required field
      content_slot: None,
    }
  }
}

pub struct RichTextNodeBuilder<'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> RichTextNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_blocks(&mut self, blocks: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<RichTextBlock<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RichTextNode::VT_BLOCKS, blocks);
  }
  #[inline]
  pub fn add_content_slot(&mut self, content_slot: flatbuffers::WIPOffset<ContentSlot<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ContentSlot>>(RichTextNode::VT_CONTENT_SLOT, content_slot);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RichTextNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RichTextNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RichTextNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RichTextNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, RichTextNode::VT_BLOCKS,"blocks");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> FormatOptions<'a> {
  pub const VT_NUMBER_STYLE: flatbuffers::VOffsetT = 4;
  pub const VT_CURRENCY_CODE: flatbuffers::VOffsetT = 6;
  pub const VT_DATE_STYLE: flatbuffers::VOffsetT = 8;
  pub const VT_CUSTOM_DATE_PATTERN: flatbuffers::VOffsetT = 10;
  pub const VT_MIN_FRACTION_DIGITS: flatbuffers::VOffsetT = 12;
  pub const VT_MAX_FRACTION_DIGITS: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FormatOptions { _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 FormatOptionsArgs<'args>
  ) -> flatbuffers::WIPOffset<FormatOptions<'bldr>> {
    let mut builder = FormatOptionsBuilder::new(_fbb);
    builder.add_max_fraction_digits(args.max_fraction_digits);
    builder.add_min_fraction_digits(args.min_fraction_digits);
    if let Some(x) = args.custom_date_pattern { builder.add_custom_date_pattern(x); }
    if let Some(x) = args.currency_code { builder.add_currency_code(x); }
    builder.add_date_style(args.date_style);
    builder.add_number_style(args.number_style);
    builder.finish()
  }


  #[inline]
  pub fn number_style(&self) -> NumberStyle {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<NumberStyle>(FormatOptions::VT_NUMBER_STYLE, Some(NumberStyle::Decimal)).unwrap()}
  }
  /// Currency code (e.g., "USD", "EUR"). Only for Currency number_style.
  #[inline]
  pub fn currency_code(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormatOptions::VT_CURRENCY_CODE, None)}
  }
  #[inline]
  pub fn date_style(&self) -> DateStyle {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<DateStyle>(FormatOptions::VT_DATE_STYLE, Some(DateStyle::Medium)).unwrap()}
  }
  /// ICU date pattern (only for Custom date_style, e.g., "yyyy-MM-dd").
  #[inline]
  pub fn custom_date_pattern(&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>>(FormatOptions::VT_CUSTOM_DATE_PATTERN, None)}
  }
  /// Minimum fraction digits for numbers.
  #[inline]
  pub fn min_fraction_digits(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(FormatOptions::VT_MIN_FRACTION_DIGITS, Some(0)).unwrap()}
  }
  /// Maximum fraction digits for numbers.
  #[inline]
  pub fn max_fraction_digits(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(FormatOptions::VT_MAX_FRACTION_DIGITS, Some(0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for FormatOptions<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<NumberStyle>("number_style", Self::VT_NUMBER_STYLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("currency_code", Self::VT_CURRENCY_CODE, false)?
     .visit_field::<DateStyle>("date_style", Self::VT_DATE_STYLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("custom_date_pattern", Self::VT_CUSTOM_DATE_PATTERN, false)?
     .visit_field::<i32>("min_fraction_digits", Self::VT_MIN_FRACTION_DIGITS, false)?
     .visit_field::<i32>("max_fraction_digits", Self::VT_MAX_FRACTION_DIGITS, false)?
     .finish();
    Ok(())
  }
}
pub struct FormatOptionsArgs<'a> {
    pub number_style: NumberStyle,
    pub currency_code: Option<flatbuffers::WIPOffset<&'a str>>,
    pub date_style: DateStyle,
    pub custom_date_pattern: Option<flatbuffers::WIPOffset<&'a str>>,
    pub min_fraction_digits: i32,
    pub max_fraction_digits: i32,
}
impl<'a> Default for FormatOptionsArgs<'a> {
  #[inline]
  fn default() -> Self {
    FormatOptionsArgs {
      number_style: NumberStyle::Decimal,
      currency_code: None,
      date_style: DateStyle::Medium,
      custom_date_pattern: None,
      min_fraction_digits: 0,
      max_fraction_digits: 0,
    }
  }
}

pub struct FormatOptionsBuilder<'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> FormatOptionsBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_number_style(&mut self, number_style: NumberStyle) {
    self.fbb_.push_slot::<NumberStyle>(FormatOptions::VT_NUMBER_STYLE, number_style, NumberStyle::Decimal);
  }
  #[inline]
  pub fn add_currency_code(&mut self, currency_code: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormatOptions::VT_CURRENCY_CODE, currency_code);
  }
  #[inline]
  pub fn add_date_style(&mut self, date_style: DateStyle) {
    self.fbb_.push_slot::<DateStyle>(FormatOptions::VT_DATE_STYLE, date_style, DateStyle::Medium);
  }
  #[inline]
  pub fn add_custom_date_pattern(&mut self, custom_date_pattern: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormatOptions::VT_CUSTOM_DATE_PATTERN, custom_date_pattern);
  }
  #[inline]
  pub fn add_min_fraction_digits(&mut self, min_fraction_digits: i32) {
    self.fbb_.push_slot::<i32>(FormatOptions::VT_MIN_FRACTION_DIGITS, min_fraction_digits, 0);
  }
  #[inline]
  pub fn add_max_fraction_digits(&mut self, max_fraction_digits: i32) {
    self.fbb_.push_slot::<i32>(FormatOptions::VT_MAX_FRACTION_DIGITS, max_fraction_digits, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FormatOptionsBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FormatOptionsBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FormatOptions<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FormatOptions<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FormatOptions");
      ds.field("number_style", &self.number_style());
      ds.field("currency_code", &self.currency_code());
      ds.field("date_style", &self.date_style());
      ds.field("custom_date_pattern", &self.custom_date_pattern());
      ds.field("min_fraction_digits", &self.min_fraction_digits());
      ds.field("max_fraction_digits", &self.max_fraction_digits());
      ds.finish()
  }
}
pub enum MessageParameterOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> MessageParameter<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_PARAM_TYPE: flatbuffers::VOffsetT = 6;
  pub const VT_FORMAT_OPTIONS: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    MessageParameter { _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 MessageParameterArgs<'args>
  ) -> flatbuffers::WIPOffset<MessageParameter<'bldr>> {
    let mut builder = MessageParameterBuilder::new(_fbb);
    if let Some(x) = args.format_options { builder.add_format_options(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_param_type(args.param_type);
    builder.finish()
  }


  /// Parameter name (e.g., "count", "name", "date").
  #[inline]
  pub fn name(&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>>(MessageParameter::VT_NAME, None).unwrap()}
  }
  #[inline]
  pub fn param_type(&self) -> MessageParamType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MessageParamType>(MessageParameter::VT_PARAM_TYPE, Some(MessageParamType::StringParam)).unwrap()}
  }
  #[inline]
  pub fn format_options(&self) -> Option<FormatOptions<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FormatOptions>>(MessageParameter::VT_FORMAT_OPTIONS, None)}
  }
}

impl flatbuffers::Verifiable for MessageParameter<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<MessageParamType>("param_type", Self::VT_PARAM_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<FormatOptions>>("format_options", Self::VT_FORMAT_OPTIONS, false)?
     .finish();
    Ok(())
  }
}
pub struct MessageParameterArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub param_type: MessageParamType,
    pub format_options: Option<flatbuffers::WIPOffset<FormatOptions<'a>>>,
}
impl<'a> Default for MessageParameterArgs<'a> {
  #[inline]
  fn default() -> Self {
    MessageParameterArgs {
      name: None, // required field
      param_type: MessageParamType::StringParam,
      format_options: None,
    }
  }
}

pub struct MessageParameterBuilder<'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> MessageParameterBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MessageParameter::VT_NAME, name);
  }
  #[inline]
  pub fn add_param_type(&mut self, param_type: MessageParamType) {
    self.fbb_.push_slot::<MessageParamType>(MessageParameter::VT_PARAM_TYPE, param_type, MessageParamType::StringParam);
  }
  #[inline]
  pub fn add_format_options(&mut self, format_options: flatbuffers::WIPOffset<FormatOptions<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FormatOptions>>(MessageParameter::VT_FORMAT_OPTIONS, format_options);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MessageParameterBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MessageParameterBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<MessageParameter<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MessageParameter::VT_NAME,"name");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> LocalizedString<'a> {
  pub const VT_MESSAGE_KEY: flatbuffers::VOffsetT = 4;
  pub const VT_DEFAULT_VALUE: flatbuffers::VOffsetT = 6;
  pub const VT_PARAMETERS: flatbuffers::VOffsetT = 8;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    LocalizedString { _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 LocalizedStringArgs<'args>
  ) -> flatbuffers::WIPOffset<LocalizedString<'bldr>> {
    let mut builder = LocalizedStringBuilder::new(_fbb);
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.parameters { builder.add_parameters(x); }
    if let Some(x) = args.default_value { builder.add_default_value(x); }
    if let Some(x) = args.message_key { builder.add_message_key(x); }
    builder.finish()
  }


  /// Message key (e.g., "hero.title", "form.email.label").
  #[inline]
  pub fn message_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>>(LocalizedString::VT_MESSAGE_KEY, None).unwrap()}
  }
  /// Default value (in the primary language). Used as fallback if
  /// the translation is missing.
  #[inline]
  pub fn default_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>>(LocalizedString::VT_DEFAULT_VALUE, None)}
  }
  /// Typed parameters for interpolation.
  #[inline]
  pub fn parameters(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<MessageParameter<'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<MessageParameter>>>>(LocalizedString::VT_PARAMETERS, None)}
  }
  /// Context description for translators (e.g., "Button label for adding item to cart").
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(LocalizedString::VT_DESCRIPTION, None)}
  }
}

impl flatbuffers::Verifiable for LocalizedString<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("message_key", Self::VT_MESSAGE_KEY, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("default_value", Self::VT_DEFAULT_VALUE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<MessageParameter>>>>("parameters", Self::VT_PARAMETERS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .finish();
    Ok(())
  }
}
pub struct LocalizedStringArgs<'a> {
    pub message_key: Option<flatbuffers::WIPOffset<&'a str>>,
    pub default_value: Option<flatbuffers::WIPOffset<&'a str>>,
    pub parameters: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<MessageParameter<'a>>>>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for LocalizedStringArgs<'a> {
  #[inline]
  fn default() -> Self {
    LocalizedStringArgs {
      message_key: None, // required field
      default_value: None,
      parameters: None,
      description: None,
    }
  }
}

pub struct LocalizedStringBuilder<'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> LocalizedStringBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_message_key(&mut self, message_key: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LocalizedString::VT_MESSAGE_KEY, message_key);
  }
  #[inline]
  pub fn add_default_value(&mut self, default_value: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LocalizedString::VT_DEFAULT_VALUE, default_value);
  }
  #[inline]
  pub fn add_parameters(&mut self, parameters: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<MessageParameter<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LocalizedString::VT_PARAMETERS, parameters);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(LocalizedString::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> LocalizedStringBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    LocalizedStringBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<LocalizedString<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, LocalizedString::VT_MESSAGE_KEY,"message_key");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> Message<'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 {
    Message { _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 MessageArgs<'args>
  ) -> flatbuffers::WIPOffset<Message<'bldr>> {
    let mut builder = MessageBuilder::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>>(Message::VT_KEY, None).unwrap()}
  }
  /// ICU MessageFormat string.
  /// Examples:
  ///   "Hello {name}"
  ///   "{count, plural, one {# item} other {# items}}"
  ///   "{gender, select, female {She} male {He} other {They}} commented"
  #[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>>(Message::VT_VALUE, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for Message<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    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 MessageArgs<'a> {
    pub key: Option<flatbuffers::WIPOffset<&'a str>>,
    pub value: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for MessageArgs<'a> {
  #[inline]
  fn default() -> Self {
    MessageArgs {
      key: None, // required field
      value: None, // required field
    }
  }
}

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

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

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

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

impl<'a> MessageCatalog<'a> {
  pub const VT_LOCALE: flatbuffers::VOffsetT = 4;
  pub const VT_MESSAGES: flatbuffers::VOffsetT = 6;
  pub const VT_FALLBACK_LOCALE: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    MessageCatalog { _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 MessageCatalogArgs<'args>
  ) -> flatbuffers::WIPOffset<MessageCatalog<'bldr>> {
    let mut builder = MessageCatalogBuilder::new(_fbb);
    if let Some(x) = args.fallback_locale { builder.add_fallback_locale(x); }
    if let Some(x) = args.messages { builder.add_messages(x); }
    if let Some(x) = args.locale { builder.add_locale(x); }
    builder.finish()
  }


  /// BCP 47 locale tag (e.g., "en-US", "fr-FR", "ar-SA").
  #[inline]
  pub fn locale(&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>>(MessageCatalog::VT_LOCALE, None).unwrap()}
  }
  /// All messages for this locale.
  #[inline]
  pub fn messages(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Message<'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<Message>>>>(MessageCatalog::VT_MESSAGES, None).unwrap()}
  }
  /// Fallback locale (e.g., "en" as fallback for "en-US").
  #[inline]
  pub fn fallback_locale(&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>>(MessageCatalog::VT_FALLBACK_LOCALE, None)}
  }
}

impl flatbuffers::Verifiable for MessageCatalog<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("locale", Self::VT_LOCALE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Message>>>>("messages", Self::VT_MESSAGES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("fallback_locale", Self::VT_FALLBACK_LOCALE, false)?
     .finish();
    Ok(())
  }
}
pub struct MessageCatalogArgs<'a> {
    pub locale: Option<flatbuffers::WIPOffset<&'a str>>,
    pub messages: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Message<'a>>>>>,
    pub fallback_locale: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for MessageCatalogArgs<'a> {
  #[inline]
  fn default() -> Self {
    MessageCatalogArgs {
      locale: None, // required field
      messages: None, // required field
      fallback_locale: None,
    }
  }
}

pub struct MessageCatalogBuilder<'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> MessageCatalogBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_locale(&mut self, locale: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MessageCatalog::VT_LOCALE, locale);
  }
  #[inline]
  pub fn add_messages(&mut self, messages: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Message<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MessageCatalog::VT_MESSAGES, messages);
  }
  #[inline]
  pub fn add_fallback_locale(&mut self, fallback_locale: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MessageCatalog::VT_FALLBACK_LOCALE, fallback_locale);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MessageCatalogBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MessageCatalogBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<MessageCatalog<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MessageCatalog::VT_LOCALE,"locale");
    self.fbb_.required(o, MessageCatalog::VT_MESSAGES,"messages");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> I18nConfig<'a> {
  pub const VT_DEFAULT_LOCALE: flatbuffers::VOffsetT = 4;
  pub const VT_SUPPORTED_LOCALES: flatbuffers::VOffsetT = 6;
  pub const VT_MODE: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    I18nConfig { _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 I18nConfigArgs<'args>
  ) -> flatbuffers::WIPOffset<I18nConfig<'bldr>> {
    let mut builder = I18nConfigBuilder::new(_fbb);
    if let Some(x) = args.mode { builder.add_mode(x); }
    if let Some(x) = args.supported_locales { builder.add_supported_locales(x); }
    if let Some(x) = args.default_locale { builder.add_default_locale(x); }
    builder.finish()
  }


  /// Default/primary locale.
  #[inline]
  pub fn default_locale(&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>>(I18nConfig::VT_DEFAULT_LOCALE, None).unwrap()}
  }
  /// All supported locales.
  #[inline]
  pub fn supported_locales(&self) -> 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>>>>(I18nConfig::VT_SUPPORTED_LOCALES, None).unwrap()}
  }
  /// Compilation mode.
  /// "static" = one output per locale (zero runtime, default).
  /// "runtime" = one output with locale switching (~1KB runtime).
  #[inline]
  pub fn mode(&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>>(I18nConfig::VT_MODE, None)}
  }
}

impl flatbuffers::Verifiable for I18nConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("default_locale", Self::VT_DEFAULT_LOCALE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("supported_locales", Self::VT_SUPPORTED_LOCALES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("mode", Self::VT_MODE, false)?
     .finish();
    Ok(())
  }
}
pub struct I18nConfigArgs<'a> {
    pub default_locale: Option<flatbuffers::WIPOffset<&'a str>>,
    pub supported_locales: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub mode: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for I18nConfigArgs<'a> {
  #[inline]
  fn default() -> Self {
    I18nConfigArgs {
      default_locale: None, // required field
      supported_locales: None, // required field
      mode: None,
    }
  }
}

pub struct I18nConfigBuilder<'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> I18nConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_default_locale(&mut self, default_locale: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(I18nConfig::VT_DEFAULT_LOCALE, default_locale);
  }
  #[inline]
  pub fn add_supported_locales(&mut self, supported_locales: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(I18nConfig::VT_SUPPORTED_LOCALES, supported_locales);
  }
  #[inline]
  pub fn add_mode(&mut self, mode: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(I18nConfig::VT_MODE, mode);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> I18nConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    I18nConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<I18nConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, I18nConfig::VT_DEFAULT_LOCALE,"default_locale");
    self.fbb_.required(o, I18nConfig::VT_SUPPORTED_LOCALES,"supported_locales");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> OpenGraphData<'a> {
  pub const VT_TITLE: flatbuffers::VOffsetT = 4;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 6;
  pub const VT_IMAGE: flatbuffers::VOffsetT = 8;
  pub const VT_IMAGE_ALT: flatbuffers::VOffsetT = 10;
  pub const VT_IMAGE_WIDTH: flatbuffers::VOffsetT = 12;
  pub const VT_IMAGE_HEIGHT: flatbuffers::VOffsetT = 14;
  pub const VT_OG_TYPE: flatbuffers::VOffsetT = 16;
  pub const VT_URL: flatbuffers::VOffsetT = 18;
  pub const VT_SITE_NAME: flatbuffers::VOffsetT = 20;
  pub const VT_LOCALE: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    OpenGraphData { _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 OpenGraphDataArgs<'args>
  ) -> flatbuffers::WIPOffset<OpenGraphData<'bldr>> {
    let mut builder = OpenGraphDataBuilder::new(_fbb);
    if let Some(x) = args.locale { builder.add_locale(x); }
    if let Some(x) = args.site_name { builder.add_site_name(x); }
    if let Some(x) = args.url { builder.add_url(x); }
    builder.add_image_height(args.image_height);
    builder.add_image_width(args.image_width);
    if let Some(x) = args.image_alt { builder.add_image_alt(x); }
    if let Some(x) = args.image { builder.add_image(x); }
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    builder.add_og_type(args.og_type);
    builder.finish()
  }


  #[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>>(OpenGraphData::VT_TITLE, None)}
  }
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(OpenGraphData::VT_DESCRIPTION, None)}
  }
  /// Image URL or MediaNode reference.
  #[inline]
  pub fn image(&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>>(OpenGraphData::VT_IMAGE, None)}
  }
  #[inline]
  pub fn image_alt(&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>>(OpenGraphData::VT_IMAGE_ALT, None)}
  }
  #[inline]
  pub fn image_width(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(OpenGraphData::VT_IMAGE_WIDTH, Some(0)).unwrap()}
  }
  #[inline]
  pub fn image_height(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(OpenGraphData::VT_IMAGE_HEIGHT, Some(0)).unwrap()}
  }
  #[inline]
  pub fn og_type(&self) -> OGType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<OGType>(OpenGraphData::VT_OG_TYPE, Some(OGType::Website)).unwrap()}
  }
  #[inline]
  pub fn url(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(OpenGraphData::VT_URL, None)}
  }
  #[inline]
  pub fn site_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>>(OpenGraphData::VT_SITE_NAME, None)}
  }
  #[inline]
  pub fn locale(&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>>(OpenGraphData::VT_LOCALE, None)}
  }
}

impl flatbuffers::Verifiable for OpenGraphData<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("image", Self::VT_IMAGE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("image_alt", Self::VT_IMAGE_ALT, false)?
     .visit_field::<i32>("image_width", Self::VT_IMAGE_WIDTH, false)?
     .visit_field::<i32>("image_height", Self::VT_IMAGE_HEIGHT, false)?
     .visit_field::<OGType>("og_type", Self::VT_OG_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("url", Self::VT_URL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("site_name", Self::VT_SITE_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("locale", Self::VT_LOCALE, false)?
     .finish();
    Ok(())
  }
}
pub struct OpenGraphDataArgs<'a> {
    pub title: Option<flatbuffers::WIPOffset<&'a str>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
    pub image: Option<flatbuffers::WIPOffset<&'a str>>,
    pub image_alt: Option<flatbuffers::WIPOffset<&'a str>>,
    pub image_width: i32,
    pub image_height: i32,
    pub og_type: OGType,
    pub url: Option<flatbuffers::WIPOffset<&'a str>>,
    pub site_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub locale: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for OpenGraphDataArgs<'a> {
  #[inline]
  fn default() -> Self {
    OpenGraphDataArgs {
      title: None,
      description: None,
      image: None,
      image_alt: None,
      image_width: 0,
      image_height: 0,
      og_type: OGType::Website,
      url: None,
      site_name: None,
      locale: None,
    }
  }
}

pub struct OpenGraphDataBuilder<'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> OpenGraphDataBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_title(&mut self, title: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_TITLE, title);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_image(&mut self, image: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_IMAGE, image);
  }
  #[inline]
  pub fn add_image_alt(&mut self, image_alt: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_IMAGE_ALT, image_alt);
  }
  #[inline]
  pub fn add_image_width(&mut self, image_width: i32) {
    self.fbb_.push_slot::<i32>(OpenGraphData::VT_IMAGE_WIDTH, image_width, 0);
  }
  #[inline]
  pub fn add_image_height(&mut self, image_height: i32) {
    self.fbb_.push_slot::<i32>(OpenGraphData::VT_IMAGE_HEIGHT, image_height, 0);
  }
  #[inline]
  pub fn add_og_type(&mut self, og_type: OGType) {
    self.fbb_.push_slot::<OGType>(OpenGraphData::VT_OG_TYPE, og_type, OGType::Website);
  }
  #[inline]
  pub fn add_url(&mut self, url: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_URL, url);
  }
  #[inline]
  pub fn add_site_name(&mut self, site_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_SITE_NAME, site_name);
  }
  #[inline]
  pub fn add_locale(&mut self, locale: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(OpenGraphData::VT_LOCALE, locale);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> OpenGraphDataBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    OpenGraphDataBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<OpenGraphData<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for OpenGraphData<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("OpenGraphData");
      ds.field("title", &self.title());
      ds.field("description", &self.description());
      ds.field("image", &self.image());
      ds.field("image_alt", &self.image_alt());
      ds.field("image_width", &self.image_width());
      ds.field("image_height", &self.image_height());
      ds.field("og_type", &self.og_type());
      ds.field("url", &self.url());
      ds.field("site_name", &self.site_name());
      ds.field("locale", &self.locale());
      ds.finish()
  }
}
pub enum TwitterCardDataOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> TwitterCardData<'a> {
  pub const VT_CARD_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_TITLE: flatbuffers::VOffsetT = 6;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 8;
  pub const VT_IMAGE: flatbuffers::VOffsetT = 10;
  pub const VT_IMAGE_ALT: flatbuffers::VOffsetT = 12;
  pub const VT_SITE: flatbuffers::VOffsetT = 14;
  pub const VT_CREATOR: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    TwitterCardData { _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 TwitterCardDataArgs<'args>
  ) -> flatbuffers::WIPOffset<TwitterCardData<'bldr>> {
    let mut builder = TwitterCardDataBuilder::new(_fbb);
    if let Some(x) = args.creator { builder.add_creator(x); }
    if let Some(x) = args.site { builder.add_site(x); }
    if let Some(x) = args.image_alt { builder.add_image_alt(x); }
    if let Some(x) = args.image { builder.add_image(x); }
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    builder.add_card_type(args.card_type);
    builder.finish()
  }


  #[inline]
  pub fn card_type(&self) -> TwitterCardType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<TwitterCardType>(TwitterCardData::VT_CARD_TYPE, Some(TwitterCardType::SummaryLargeImage)).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>>(TwitterCardData::VT_TITLE, None)}
  }
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(TwitterCardData::VT_DESCRIPTION, None)}
  }
  #[inline]
  pub fn image(&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>>(TwitterCardData::VT_IMAGE, None)}
  }
  #[inline]
  pub fn image_alt(&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>>(TwitterCardData::VT_IMAGE_ALT, None)}
  }
  #[inline]
  pub fn site(&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>>(TwitterCardData::VT_SITE, None)}
  }
  #[inline]
  pub fn creator(&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>>(TwitterCardData::VT_CREATOR, None)}
  }
}

impl flatbuffers::Verifiable for TwitterCardData<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<TwitterCardType>("card_type", Self::VT_CARD_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("image", Self::VT_IMAGE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("image_alt", Self::VT_IMAGE_ALT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("site", Self::VT_SITE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("creator", Self::VT_CREATOR, false)?
     .finish();
    Ok(())
  }
}
pub struct TwitterCardDataArgs<'a> {
    pub card_type: TwitterCardType,
    pub title: Option<flatbuffers::WIPOffset<&'a str>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
    pub image: Option<flatbuffers::WIPOffset<&'a str>>,
    pub image_alt: Option<flatbuffers::WIPOffset<&'a str>>,
    pub site: Option<flatbuffers::WIPOffset<&'a str>>,
    pub creator: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for TwitterCardDataArgs<'a> {
  #[inline]
  fn default() -> Self {
    TwitterCardDataArgs {
      card_type: TwitterCardType::SummaryLargeImage,
      title: None,
      description: None,
      image: None,
      image_alt: None,
      site: None,
      creator: None,
    }
  }
}

pub struct TwitterCardDataBuilder<'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> TwitterCardDataBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_card_type(&mut self, card_type: TwitterCardType) {
    self.fbb_.push_slot::<TwitterCardType>(TwitterCardData::VT_CARD_TYPE, card_type, TwitterCardType::SummaryLargeImage);
  }
  #[inline]
  pub fn add_title(&mut self, title: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_TITLE, title);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_image(&mut self, image: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_IMAGE, image);
  }
  #[inline]
  pub fn add_image_alt(&mut self, image_alt: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_IMAGE_ALT, image_alt);
  }
  #[inline]
  pub fn add_site(&mut self, site: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_SITE, site);
  }
  #[inline]
  pub fn add_creator(&mut self, creator: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TwitterCardData::VT_CREATOR, creator);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TwitterCardDataBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TwitterCardDataBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<TwitterCardData<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for TwitterCardData<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("TwitterCardData");
      ds.field("card_type", &self.card_type());
      ds.field("title", &self.title());
      ds.field("description", &self.description());
      ds.field("image", &self.image());
      ds.field("image_alt", &self.image_alt());
      ds.field("site", &self.site());
      ds.field("creator", &self.creator());
      ds.finish()
  }
}
pub enum RobotsDirectiveOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> RobotsDirective<'a> {
  pub const VT_INDEX: flatbuffers::VOffsetT = 4;
  pub const VT_FOLLOW_: flatbuffers::VOffsetT = 6;
  pub const VT_MAX_SNIPPET: flatbuffers::VOffsetT = 8;
  pub const VT_MAX_IMAGE_PREVIEW: flatbuffers::VOffsetT = 10;
  pub const VT_MAX_VIDEO_PREVIEW: flatbuffers::VOffsetT = 12;
  pub const VT_NO_ARCHIVE: flatbuffers::VOffsetT = 14;
  pub const VT_NO_TRANSLATE: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RobotsDirective { _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 RobotsDirectiveArgs
  ) -> flatbuffers::WIPOffset<RobotsDirective<'bldr>> {
    let mut builder = RobotsDirectiveBuilder::new(_fbb);
    builder.add_max_video_preview(args.max_video_preview);
    builder.add_max_snippet(args.max_snippet);
    builder.add_no_translate(args.no_translate);
    builder.add_no_archive(args.no_archive);
    builder.add_max_image_preview(args.max_image_preview);
    builder.add_follow_(args.follow_);
    builder.add_index(args.index);
    builder.finish()
  }


  #[inline]
  pub fn index(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RobotsDirective::VT_INDEX, Some(true)).unwrap()}
  }
  #[inline]
  pub fn follow_(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RobotsDirective::VT_FOLLOW_, Some(true)).unwrap()}
  }
  #[inline]
  pub fn max_snippet(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(RobotsDirective::VT_MAX_SNIPPET, Some(-1)).unwrap()}
  }
  #[inline]
  pub fn max_image_preview(&self) -> ImagePreviewSize {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ImagePreviewSize>(RobotsDirective::VT_MAX_IMAGE_PREVIEW, Some(ImagePreviewSize::Large)).unwrap()}
  }
  #[inline]
  pub fn max_video_preview(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(RobotsDirective::VT_MAX_VIDEO_PREVIEW, Some(-1)).unwrap()}
  }
  #[inline]
  pub fn no_archive(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RobotsDirective::VT_NO_ARCHIVE, Some(false)).unwrap()}
  }
  #[inline]
  pub fn no_translate(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(RobotsDirective::VT_NO_TRANSLATE, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for RobotsDirective<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<bool>("index", Self::VT_INDEX, false)?
     .visit_field::<bool>("follow_", Self::VT_FOLLOW_, false)?
     .visit_field::<i32>("max_snippet", Self::VT_MAX_SNIPPET, false)?
     .visit_field::<ImagePreviewSize>("max_image_preview", Self::VT_MAX_IMAGE_PREVIEW, false)?
     .visit_field::<i32>("max_video_preview", Self::VT_MAX_VIDEO_PREVIEW, false)?
     .visit_field::<bool>("no_archive", Self::VT_NO_ARCHIVE, false)?
     .visit_field::<bool>("no_translate", Self::VT_NO_TRANSLATE, false)?
     .finish();
    Ok(())
  }
}
pub struct RobotsDirectiveArgs {
    pub index: bool,
    pub follow_: bool,
    pub max_snippet: i32,
    pub max_image_preview: ImagePreviewSize,
    pub max_video_preview: i32,
    pub no_archive: bool,
    pub no_translate: bool,
}
impl<'a> Default for RobotsDirectiveArgs {
  #[inline]
  fn default() -> Self {
    RobotsDirectiveArgs {
      index: true,
      follow_: true,
      max_snippet: -1,
      max_image_preview: ImagePreviewSize::Large,
      max_video_preview: -1,
      no_archive: false,
      no_translate: false,
    }
  }
}

pub struct RobotsDirectiveBuilder<'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> RobotsDirectiveBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_index(&mut self, index: bool) {
    self.fbb_.push_slot::<bool>(RobotsDirective::VT_INDEX, index, true);
  }
  #[inline]
  pub fn add_follow_(&mut self, follow_: bool) {
    self.fbb_.push_slot::<bool>(RobotsDirective::VT_FOLLOW_, follow_, true);
  }
  #[inline]
  pub fn add_max_snippet(&mut self, max_snippet: i32) {
    self.fbb_.push_slot::<i32>(RobotsDirective::VT_MAX_SNIPPET, max_snippet, -1);
  }
  #[inline]
  pub fn add_max_image_preview(&mut self, max_image_preview: ImagePreviewSize) {
    self.fbb_.push_slot::<ImagePreviewSize>(RobotsDirective::VT_MAX_IMAGE_PREVIEW, max_image_preview, ImagePreviewSize::Large);
  }
  #[inline]
  pub fn add_max_video_preview(&mut self, max_video_preview: i32) {
    self.fbb_.push_slot::<i32>(RobotsDirective::VT_MAX_VIDEO_PREVIEW, max_video_preview, -1);
  }
  #[inline]
  pub fn add_no_archive(&mut self, no_archive: bool) {
    self.fbb_.push_slot::<bool>(RobotsDirective::VT_NO_ARCHIVE, no_archive, false);
  }
  #[inline]
  pub fn add_no_translate(&mut self, no_translate: bool) {
    self.fbb_.push_slot::<bool>(RobotsDirective::VT_NO_TRANSLATE, no_translate, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RobotsDirectiveBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RobotsDirectiveBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RobotsDirective<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> StructuredData<'a> {
  pub const VT_SCHEMA_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_PROPERTIES_JSON: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    StructuredData { _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 StructuredDataArgs<'args>
  ) -> flatbuffers::WIPOffset<StructuredData<'bldr>> {
    let mut builder = StructuredDataBuilder::new(_fbb);
    if let Some(x) = args.properties_json { builder.add_properties_json(x); }
    if let Some(x) = args.schema_type { builder.add_schema_type(x); }
    builder.finish()
  }


  /// Schema.org type (e.g., "Article", "Product", "FAQ", "BreadcrumbList").
  #[inline]
  pub fn schema_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>>(StructuredData::VT_SCHEMA_TYPE, None).unwrap()}
  }
  /// JSON-LD properties as a JSON string. The validator checks basic
  /// conformance to the declared schema_type.
  #[inline]
  pub fn properties_json(&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>>(StructuredData::VT_PROPERTIES_JSON, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for StructuredData<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("schema_type", Self::VT_SCHEMA_TYPE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("properties_json", Self::VT_PROPERTIES_JSON, true)?
     .finish();
    Ok(())
  }
}
pub struct StructuredDataArgs<'a> {
    pub schema_type: Option<flatbuffers::WIPOffset<&'a str>>,
    pub properties_json: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for StructuredDataArgs<'a> {
  #[inline]
  fn default() -> Self {
    StructuredDataArgs {
      schema_type: None, // required field
      properties_json: None, // required field
    }
  }
}

pub struct StructuredDataBuilder<'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> StructuredDataBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_schema_type(&mut self, schema_type: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StructuredData::VT_SCHEMA_TYPE, schema_type);
  }
  #[inline]
  pub fn add_properties_json(&mut self, properties_json: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StructuredData::VT_PROPERTIES_JSON, properties_json);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StructuredDataBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    StructuredDataBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<StructuredData<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, StructuredData::VT_SCHEMA_TYPE,"schema_type");
    self.fbb_.required(o, StructuredData::VT_PROPERTIES_JSON,"properties_json");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AlternateLink<'a> {
  pub const VT_HREFLANG: flatbuffers::VOffsetT = 4;
  pub const VT_HREF: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AlternateLink { _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 AlternateLinkArgs<'args>
  ) -> flatbuffers::WIPOffset<AlternateLink<'bldr>> {
    let mut builder = AlternateLinkBuilder::new(_fbb);
    if let Some(x) = args.href { builder.add_href(x); }
    if let Some(x) = args.hreflang { builder.add_hreflang(x); }
    builder.finish()
  }


  /// BCP 47 language tag (e.g., "en-US", "fr-FR", "x-default").
  #[inline]
  pub fn hreflang(&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>>(AlternateLink::VT_HREFLANG, None).unwrap()}
  }
  /// URL of the alternate page.
  #[inline]
  pub fn href(&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>>(AlternateLink::VT_HREF, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for AlternateLink<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("hreflang", Self::VT_HREFLANG, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("href", Self::VT_HREF, true)?
     .finish();
    Ok(())
  }
}
pub struct AlternateLinkArgs<'a> {
    pub hreflang: Option<flatbuffers::WIPOffset<&'a str>>,
    pub href: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AlternateLinkArgs<'a> {
  #[inline]
  fn default() -> Self {
    AlternateLinkArgs {
      hreflang: None, // required field
      href: None, // required field
    }
  }
}

pub struct AlternateLinkBuilder<'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> AlternateLinkBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_hreflang(&mut self, hreflang: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AlternateLink::VT_HREFLANG, hreflang);
  }
  #[inline]
  pub fn add_href(&mut self, href: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AlternateLink::VT_HREF, href);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AlternateLinkBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AlternateLinkBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AlternateLink<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AlternateLink::VT_HREFLANG,"hreflang");
    self.fbb_.required(o, AlternateLink::VT_HREF,"href");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> MetaTag<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_CONTENT: flatbuffers::VOffsetT = 6;
  pub const VT_IS_PROPERTY: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    MetaTag { _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 MetaTagArgs<'args>
  ) -> flatbuffers::WIPOffset<MetaTag<'bldr>> {
    let mut builder = MetaTagBuilder::new(_fbb);
    if let Some(x) = args.content { builder.add_content(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_is_property(args.is_property);
    builder.finish()
  }


  /// name or property attribute.
  #[inline]
  pub fn name(&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>>(MetaTag::VT_NAME, None).unwrap()}
  }
  /// content attribute value.
  #[inline]
  pub fn content(&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>>(MetaTag::VT_CONTENT, None).unwrap()}
  }
  /// If true, use property= instead of name= (for OG-like tags).
  #[inline]
  pub fn is_property(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(MetaTag::VT_IS_PROPERTY, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for MetaTag<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("content", Self::VT_CONTENT, true)?
     .visit_field::<bool>("is_property", Self::VT_IS_PROPERTY, false)?
     .finish();
    Ok(())
  }
}
pub struct MetaTagArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub content: Option<flatbuffers::WIPOffset<&'a str>>,
    pub is_property: bool,
}
impl<'a> Default for MetaTagArgs<'a> {
  #[inline]
  fn default() -> Self {
    MetaTagArgs {
      name: None, // required field
      content: None, // required field
      is_property: false,
    }
  }
}

pub struct MetaTagBuilder<'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> MetaTagBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MetaTag::VT_NAME, name);
  }
  #[inline]
  pub fn add_content(&mut self, content: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MetaTag::VT_CONTENT, content);
  }
  #[inline]
  pub fn add_is_property(&mut self, is_property: bool) {
    self.fbb_.push_slot::<bool>(MetaTag::VT_IS_PROPERTY, is_property, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MetaTagBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MetaTagBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<MetaTag<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MetaTag::VT_NAME,"name");
    self.fbb_.required(o, MetaTag::VT_CONTENT,"content");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> PageMetadata<'a> {
  pub const VT_TITLE: flatbuffers::VOffsetT = 4;
  pub const VT_TITLE_TEMPLATE: flatbuffers::VOffsetT = 6;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 8;
  pub const VT_CANONICAL_URL: flatbuffers::VOffsetT = 10;
  pub const VT_ROBOTS: flatbuffers::VOffsetT = 12;
  pub const VT_OPEN_GRAPH: flatbuffers::VOffsetT = 14;
  pub const VT_TWITTER_CARD: flatbuffers::VOffsetT = 16;
  pub const VT_ALTERNATES: flatbuffers::VOffsetT = 18;
  pub const VT_STRUCTURED_DATA: flatbuffers::VOffsetT = 20;
  pub const VT_CUSTOM_META: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    PageMetadata { _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 PageMetadataArgs<'args>
  ) -> flatbuffers::WIPOffset<PageMetadata<'bldr>> {
    let mut builder = PageMetadataBuilder::new(_fbb);
    if let Some(x) = args.custom_meta { builder.add_custom_meta(x); }
    if let Some(x) = args.structured_data { builder.add_structured_data(x); }
    if let Some(x) = args.alternates { builder.add_alternates(x); }
    if let Some(x) = args.twitter_card { builder.add_twitter_card(x); }
    if let Some(x) = args.open_graph { builder.add_open_graph(x); }
    if let Some(x) = args.robots { builder.add_robots(x); }
    if let Some(x) = args.canonical_url { builder.add_canonical_url(x); }
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.title_template { builder.add_title_template(x); }
    if let Some(x) = args.title { builder.add_title(x); }
    builder.finish()
  }


  /// Page title. The validator warns if > 60 characters.
  #[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>>(PageMetadata::VT_TITLE, None).unwrap()}
  }
  /// Title template (e.g., "%s | My Site"). %s is replaced with title.
  #[inline]
  pub fn title_template(&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>>(PageMetadata::VT_TITLE_TEMPLATE, None)}
  }
  /// Meta description. Validator warns if > 160 characters.
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(PageMetadata::VT_DESCRIPTION, None)}
  }
  /// Canonical URL for this page.
  #[inline]
  pub fn canonical_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>>(PageMetadata::VT_CANONICAL_URL, None)}
  }
  #[inline]
  pub fn robots(&self) -> Option<RobotsDirective<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RobotsDirective>>(PageMetadata::VT_ROBOTS, None)}
  }
  #[inline]
  pub fn open_graph(&self) -> Option<OpenGraphData<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<OpenGraphData>>(PageMetadata::VT_OPEN_GRAPH, None)}
  }
  #[inline]
  pub fn twitter_card(&self) -> Option<TwitterCardData<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<TwitterCardData>>(PageMetadata::VT_TWITTER_CARD, None)}
  }
  /// Hreflang alternate links (for i18n).
  #[inline]
  pub fn alternates(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AlternateLink<'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<AlternateLink>>>>(PageMetadata::VT_ALTERNATES, None)}
  }
  /// Structured data blocks (JSON-LD).
  #[inline]
  pub fn structured_data(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<StructuredData<'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<StructuredData>>>>(PageMetadata::VT_STRUCTURED_DATA, None)}
  }
  /// Custom meta tags (escape hatch).
  #[inline]
  pub fn custom_meta(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<MetaTag<'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<MetaTag>>>>(PageMetadata::VT_CUSTOM_META, None)}
  }
}

impl flatbuffers::Verifiable for PageMetadata<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("title", Self::VT_TITLE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("title_template", Self::VT_TITLE_TEMPLATE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("canonical_url", Self::VT_CANONICAL_URL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<RobotsDirective>>("robots", Self::VT_ROBOTS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<OpenGraphData>>("open_graph", Self::VT_OPEN_GRAPH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<TwitterCardData>>("twitter_card", Self::VT_TWITTER_CARD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AlternateLink>>>>("alternates", Self::VT_ALTERNATES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<StructuredData>>>>("structured_data", Self::VT_STRUCTURED_DATA, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<MetaTag>>>>("custom_meta", Self::VT_CUSTOM_META, false)?
     .finish();
    Ok(())
  }
}
pub struct PageMetadataArgs<'a> {
    pub title: Option<flatbuffers::WIPOffset<&'a str>>,
    pub title_template: Option<flatbuffers::WIPOffset<&'a str>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
    pub canonical_url: Option<flatbuffers::WIPOffset<&'a str>>,
    pub robots: Option<flatbuffers::WIPOffset<RobotsDirective<'a>>>,
    pub open_graph: Option<flatbuffers::WIPOffset<OpenGraphData<'a>>>,
    pub twitter_card: Option<flatbuffers::WIPOffset<TwitterCardData<'a>>>,
    pub alternates: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AlternateLink<'a>>>>>,
    pub structured_data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<StructuredData<'a>>>>>,
    pub custom_meta: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<MetaTag<'a>>>>>,
}
impl<'a> Default for PageMetadataArgs<'a> {
  #[inline]
  fn default() -> Self {
    PageMetadataArgs {
      title: None, // required field
      title_template: None,
      description: None,
      canonical_url: None,
      robots: None,
      open_graph: None,
      twitter_card: None,
      alternates: None,
      structured_data: None,
      custom_meta: None,
    }
  }
}

pub struct PageMetadataBuilder<'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> PageMetadataBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_title(&mut self, title: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_TITLE, title);
  }
  #[inline]
  pub fn add_title_template(&mut self, title_template: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_TITLE_TEMPLATE, title_template);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_canonical_url(&mut self, canonical_url: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_CANONICAL_URL, canonical_url);
  }
  #[inline]
  pub fn add_robots(&mut self, robots: flatbuffers::WIPOffset<RobotsDirective<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RobotsDirective>>(PageMetadata::VT_ROBOTS, robots);
  }
  #[inline]
  pub fn add_open_graph(&mut self, open_graph: flatbuffers::WIPOffset<OpenGraphData<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<OpenGraphData>>(PageMetadata::VT_OPEN_GRAPH, open_graph);
  }
  #[inline]
  pub fn add_twitter_card(&mut self, twitter_card: flatbuffers::WIPOffset<TwitterCardData<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<TwitterCardData>>(PageMetadata::VT_TWITTER_CARD, twitter_card);
  }
  #[inline]
  pub fn add_alternates(&mut self, alternates: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AlternateLink<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_ALTERNATES, alternates);
  }
  #[inline]
  pub fn add_structured_data(&mut self, structured_data: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<StructuredData<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_STRUCTURED_DATA, structured_data);
  }
  #[inline]
  pub fn add_custom_meta(&mut self, custom_meta: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<MetaTag<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(PageMetadata::VT_CUSTOM_META, custom_meta);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> PageMetadataBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PageMetadataBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<PageMetadata<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, PageMetadata::VT_TITLE,"title");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for PageMetadata<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("PageMetadata");
      ds.field("title", &self.title());
      ds.field("title_template", &self.title_template());
      ds.field("description", &self.description());
      ds.field("canonical_url", &self.canonical_url());
      ds.field("robots", &self.robots());
      ds.field("open_graph", &self.open_graph());
      ds.field("twitter_card", &self.twitter_card());
      ds.field("alternates", &self.alternates());
      ds.field("structured_data", &self.structured_data());
      ds.field("custom_meta", &self.custom_meta());
      ds.finish()
  }
}
pub enum ValidationRuleOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

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

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


  #[inline]
  pub fn rule_type(&self) -> ValidationType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ValidationType>(ValidationRule::VT_RULE_TYPE, Some(ValidationType::Required)).unwrap()}
  }
  /// Value for the rule (e.g., min_length: "8", pattern: "^[a-z]+$").
  #[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>>(ValidationRule::VT_VALUE, None)}
  }
  /// Error message (should be a LocalizedString key in production).
  #[inline]
  pub fn message(&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>>(ValidationRule::VT_MESSAGE, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for ValidationRule<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<ValidationType>("rule_type", Self::VT_RULE_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, true)?
     .finish();
    Ok(())
  }
}
pub struct ValidationRuleArgs<'a> {
    pub rule_type: ValidationType,
    pub value: Option<flatbuffers::WIPOffset<&'a str>>,
    pub message: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ValidationRuleArgs<'a> {
  #[inline]
  fn default() -> Self {
    ValidationRuleArgs {
      rule_type: ValidationType::Required,
      value: None,
      message: None, // required field
    }
  }
}

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

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

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

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

impl<'a> AsyncValidation<'a> {
  pub const VT_ENDPOINT: flatbuffers::VOffsetT = 4;
  pub const VT_DEBOUNCE_MS: flatbuffers::VOffsetT = 6;
  pub const VT_MESSAGE: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AsyncValidation { _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 AsyncValidationArgs<'args>
  ) -> flatbuffers::WIPOffset<AsyncValidation<'bldr>> {
    let mut builder = AsyncValidationBuilder::new(_fbb);
    if let Some(x) = args.message { builder.add_message(x); }
    builder.add_debounce_ms(args.debounce_ms);
    if let Some(x) = args.endpoint { builder.add_endpoint(x); }
    builder.finish()
  }


  /// Endpoint to check against (e.g., /api/check-email).
  #[inline]
  pub fn endpoint(&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>>(AsyncValidation::VT_ENDPOINT, None).unwrap()}
  }
  /// Debounce delay in ms before sending the request.
  #[inline]
  pub fn debounce_ms(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(AsyncValidation::VT_DEBOUNCE_MS, Some(300)).unwrap()}
  }
  /// Error message if validation fails.
  #[inline]
  pub fn message(&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>>(AsyncValidation::VT_MESSAGE, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for AsyncValidation<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("endpoint", Self::VT_ENDPOINT, true)?
     .visit_field::<u32>("debounce_ms", Self::VT_DEBOUNCE_MS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, true)?
     .finish();
    Ok(())
  }
}
pub struct AsyncValidationArgs<'a> {
    pub endpoint: Option<flatbuffers::WIPOffset<&'a str>>,
    pub debounce_ms: u32,
    pub message: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AsyncValidationArgs<'a> {
  #[inline]
  fn default() -> Self {
    AsyncValidationArgs {
      endpoint: None, // required field
      debounce_ms: 300,
      message: None, // required field
    }
  }
}

pub struct AsyncValidationBuilder<'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> AsyncValidationBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_endpoint(&mut self, endpoint: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AsyncValidation::VT_ENDPOINT, endpoint);
  }
  #[inline]
  pub fn add_debounce_ms(&mut self, debounce_ms: u32) {
    self.fbb_.push_slot::<u32>(AsyncValidation::VT_DEBOUNCE_MS, debounce_ms, 300);
  }
  #[inline]
  pub fn add_message(&mut self, message: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AsyncValidation::VT_MESSAGE, message);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AsyncValidationBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AsyncValidationBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AsyncValidation<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AsyncValidation::VT_ENDPOINT,"endpoint");
    self.fbb_.required(o, AsyncValidation::VT_MESSAGE,"message");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> CrossFieldValidation<'a> {
  pub const VT_FIELD_NAMES: flatbuffers::VOffsetT = 4;
  pub const VT_EXPRESSION: flatbuffers::VOffsetT = 6;
  pub const VT_MESSAGE: flatbuffers::VOffsetT = 8;
  pub const VT_TARGET_FIELD: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    CrossFieldValidation { _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 CrossFieldValidationArgs<'args>
  ) -> flatbuffers::WIPOffset<CrossFieldValidation<'bldr>> {
    let mut builder = CrossFieldValidationBuilder::new(_fbb);
    if let Some(x) = args.target_field { builder.add_target_field(x); }
    if let Some(x) = args.message { builder.add_message(x); }
    if let Some(x) = args.expression { builder.add_expression(x); }
    if let Some(x) = args.field_names { builder.add_field_names(x); }
    builder.finish()
  }


  /// Field names involved in this validation.
  #[inline]
  pub fn field_names(&self) -> 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>>>>(CrossFieldValidation::VT_FIELD_NAMES, None).unwrap()}
  }
  /// Expression that must evaluate to true (e.g., "password == confirm_password").
  #[inline]
  pub fn expression(&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>>(CrossFieldValidation::VT_EXPRESSION, None).unwrap()}
  }
  /// Error message.
  #[inline]
  pub fn message(&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>>(CrossFieldValidation::VT_MESSAGE, None).unwrap()}
  }
  /// Which field shows the error.
  #[inline]
  pub fn target_field(&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>>(CrossFieldValidation::VT_TARGET_FIELD, None)}
  }
}

impl flatbuffers::Verifiable for CrossFieldValidation<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("field_names", Self::VT_FIELD_NAMES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("expression", Self::VT_EXPRESSION, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("message", Self::VT_MESSAGE, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("target_field", Self::VT_TARGET_FIELD, false)?
     .finish();
    Ok(())
  }
}
pub struct CrossFieldValidationArgs<'a> {
    pub field_names: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub expression: Option<flatbuffers::WIPOffset<&'a str>>,
    pub message: Option<flatbuffers::WIPOffset<&'a str>>,
    pub target_field: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for CrossFieldValidationArgs<'a> {
  #[inline]
  fn default() -> Self {
    CrossFieldValidationArgs {
      field_names: None, // required field
      expression: None, // required field
      message: None, // required field
      target_field: None,
    }
  }
}

pub struct CrossFieldValidationBuilder<'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> CrossFieldValidationBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_field_names(&mut self, field_names: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CrossFieldValidation::VT_FIELD_NAMES, field_names);
  }
  #[inline]
  pub fn add_expression(&mut self, expression: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CrossFieldValidation::VT_EXPRESSION, expression);
  }
  #[inline]
  pub fn add_message(&mut self, message: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CrossFieldValidation::VT_MESSAGE, message);
  }
  #[inline]
  pub fn add_target_field(&mut self, target_field: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CrossFieldValidation::VT_TARGET_FIELD, target_field);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> CrossFieldValidationBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CrossFieldValidationBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<CrossFieldValidation<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, CrossFieldValidation::VT_FIELD_NAMES,"field_names");
    self.fbb_.required(o, CrossFieldValidation::VT_EXPRESSION,"expression");
    self.fbb_.required(o, CrossFieldValidation::VT_MESSAGE,"message");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> SelectOption<'a> {
  pub const VT_LABEL: flatbuffers::VOffsetT = 4;
  pub const VT_VALUE: flatbuffers::VOffsetT = 6;
  pub const VT_DISABLED: flatbuffers::VOffsetT = 8;

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


  #[inline]
  pub fn label(&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>>(SelectOption::VT_LABEL, 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>>(SelectOption::VT_VALUE, None).unwrap()}
  }
  #[inline]
  pub fn disabled(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(SelectOption::VT_DISABLED, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for SelectOption<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("label", Self::VT_LABEL, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, true)?
     .visit_field::<bool>("disabled", Self::VT_DISABLED, false)?
     .finish();
    Ok(())
  }
}
pub struct SelectOptionArgs<'a> {
    pub label: Option<flatbuffers::WIPOffset<&'a str>>,
    pub value: Option<flatbuffers::WIPOffset<&'a str>>,
    pub disabled: bool,
}
impl<'a> Default for SelectOptionArgs<'a> {
  #[inline]
  fn default() -> Self {
    SelectOptionArgs {
      label: None, // required field
      value: None, // required field
      disabled: false,
    }
  }
}

pub struct SelectOptionBuilder<'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> SelectOptionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_label(&mut self, label: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SelectOption::VT_LABEL, label);
  }
  #[inline]
  pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SelectOption::VT_VALUE, value);
  }
  #[inline]
  pub fn add_disabled(&mut self, disabled: bool) {
    self.fbb_.push_slot::<bool>(SelectOption::VT_DISABLED, disabled, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SelectOptionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SelectOptionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SelectOption<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, SelectOption::VT_LABEL,"label");
    self.fbb_.required(o, SelectOption::VT_VALUE,"value");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> FormField<'a> {
  pub const VT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_FIELD_TYPE: flatbuffers::VOffsetT = 6;
  pub const VT_LABEL: flatbuffers::VOffsetT = 8;
  pub const VT_PLACEHOLDER: flatbuffers::VOffsetT = 10;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 12;
  pub const VT_INITIAL_VALUE: flatbuffers::VOffsetT = 14;
  pub const VT_VALIDATIONS: flatbuffers::VOffsetT = 16;
  pub const VT_ASYNC_VALIDATIONS: flatbuffers::VOffsetT = 18;
  pub const VT_OPTIONS: flatbuffers::VOffsetT = 20;
  pub const VT_VISIBLE_WHEN: flatbuffers::VOffsetT = 22;
  pub const VT_DISABLED_WHEN: flatbuffers::VOffsetT = 24;
  pub const VT_AUTOCOMPLETE: flatbuffers::VOffsetT = 26;
  pub const VT_ACCEPT: flatbuffers::VOffsetT = 28;
  pub const VT_MAX_FILE_SIZE: flatbuffers::VOffsetT = 30;
  pub const VT_MULTIPLE: flatbuffers::VOffsetT = 32;
  pub const VT_STEP: flatbuffers::VOffsetT = 34;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 36;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FormField { _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 FormFieldArgs<'args>
  ) -> flatbuffers::WIPOffset<FormField<'bldr>> {
    let mut builder = FormFieldBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    builder.add_step(args.step);
    builder.add_max_file_size(args.max_file_size);
    if let Some(x) = args.accept { builder.add_accept(x); }
    if let Some(x) = args.disabled_when { builder.add_disabled_when(x); }
    if let Some(x) = args.visible_when { builder.add_visible_when(x); }
    if let Some(x) = args.options { builder.add_options(x); }
    if let Some(x) = args.async_validations { builder.add_async_validations(x); }
    if let Some(x) = args.validations { builder.add_validations(x); }
    if let Some(x) = args.initial_value { builder.add_initial_value(x); }
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.placeholder { builder.add_placeholder(x); }
    if let Some(x) = args.label { builder.add_label(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_multiple(args.multiple);
    builder.add_autocomplete(args.autocomplete);
    builder.add_field_type(args.field_type);
    builder.finish()
  }


  /// Field identifier (used as form submission key).
  #[inline]
  pub fn name(&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>>(FormField::VT_NAME, None).unwrap()}
  }
  #[inline]
  pub fn field_type(&self) -> FormFieldType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<FormFieldType>(FormField::VT_FIELD_TYPE, Some(FormFieldType::Text)).unwrap()}
  }
  /// Visible label (required for accessibility).
  #[inline]
  pub fn label(&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>>(FormField::VT_LABEL, None).unwrap()}
  }
  #[inline]
  pub fn placeholder(&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>>(FormField::VT_PLACEHOLDER, None)}
  }
  /// Help text displayed below the field (aria-describedby).
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormField::VT_DESCRIPTION, None)}
  }
  /// Default value.
  #[inline]
  pub fn initial_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>>(FormField::VT_INITIAL_VALUE, None)}
  }
  /// Validation rules (run client-side).
  #[inline]
  pub fn validations(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ValidationRule<'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<ValidationRule>>>>(FormField::VT_VALIDATIONS, None)}
  }
  /// Server-side async validations (e.g., uniqueness check).
  #[inline]
  pub fn async_validations(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AsyncValidation<'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<AsyncValidation>>>>(FormField::VT_ASYNC_VALIDATIONS, None)}
  }
  /// For Select/Radio: available options.
  #[inline]
  pub fn options(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SelectOption<'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<SelectOption>>>>(FormField::VT_OPTIONS, None)}
  }
  /// Conditional visibility (reference to a ComputeNode or expression).
  #[inline]
  pub fn visible_when(&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>>(FormField::VT_VISIBLE_WHEN, None)}
  }
  /// Conditional disable.
  #[inline]
  pub fn disabled_when(&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>>(FormField::VT_DISABLED_WHEN, None)}
  }
  /// Browser autocomplete hint.
  #[inline]
  pub fn autocomplete(&self) -> AutocompleteHint {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<AutocompleteHint>(FormField::VT_AUTOCOMPLETE, Some(AutocompleteHint::Off)).unwrap()}
  }
  /// For File: accepted MIME types (e.g., "image/*", ".pdf").
  #[inline]
  pub fn accept(&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>>(FormField::VT_ACCEPT, None)}
  }
  /// For File: max file size in bytes.
  #[inline]
  pub fn max_file_size(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(FormField::VT_MAX_FILE_SIZE, Some(0)).unwrap()}
  }
  /// For File: allow multiple files.
  #[inline]
  pub fn multiple(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(FormField::VT_MULTIPLE, Some(false)).unwrap()}
  }
  /// For Number/Range: step value.
  #[inline]
  pub fn step(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(FormField::VT_STEP, Some(0.0)).unwrap()}
  }
  /// Accessibility.
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormField::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for FormField<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<FormFieldType>("field_type", Self::VT_FIELD_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("label", Self::VT_LABEL, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("placeholder", Self::VT_PLACEHOLDER, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("initial_value", Self::VT_INITIAL_VALUE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ValidationRule>>>>("validations", Self::VT_VALIDATIONS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AsyncValidation>>>>("async_validations", Self::VT_ASYNC_VALIDATIONS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SelectOption>>>>("options", Self::VT_OPTIONS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("visible_when", Self::VT_VISIBLE_WHEN, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("disabled_when", Self::VT_DISABLED_WHEN, false)?
     .visit_field::<AutocompleteHint>("autocomplete", Self::VT_AUTOCOMPLETE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("accept", Self::VT_ACCEPT, false)?
     .visit_field::<u32>("max_file_size", Self::VT_MAX_FILE_SIZE, false)?
     .visit_field::<bool>("multiple", Self::VT_MULTIPLE, false)?
     .visit_field::<f32>("step", Self::VT_STEP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct FormFieldArgs<'a> {
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub field_type: FormFieldType,
    pub label: Option<flatbuffers::WIPOffset<&'a str>>,
    pub placeholder: Option<flatbuffers::WIPOffset<&'a str>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
    pub initial_value: Option<flatbuffers::WIPOffset<&'a str>>,
    pub validations: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ValidationRule<'a>>>>>,
    pub async_validations: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AsyncValidation<'a>>>>>,
    pub options: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SelectOption<'a>>>>>,
    pub visible_when: Option<flatbuffers::WIPOffset<&'a str>>,
    pub disabled_when: Option<flatbuffers::WIPOffset<&'a str>>,
    pub autocomplete: AutocompleteHint,
    pub accept: Option<flatbuffers::WIPOffset<&'a str>>,
    pub max_file_size: u32,
    pub multiple: bool,
    pub step: f32,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for FormFieldArgs<'a> {
  #[inline]
  fn default() -> Self {
    FormFieldArgs {
      name: None, // required field
      field_type: FormFieldType::Text,
      label: None, // required field
      placeholder: None,
      description: None,
      initial_value: None,
      validations: None,
      async_validations: None,
      options: None,
      visible_when: None,
      disabled_when: None,
      autocomplete: AutocompleteHint::Off,
      accept: None,
      max_file_size: 0,
      multiple: false,
      step: 0.0,
      semantic_node_id: None,
    }
  }
}

pub struct FormFieldBuilder<'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> FormFieldBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_NAME, name);
  }
  #[inline]
  pub fn add_field_type(&mut self, field_type: FormFieldType) {
    self.fbb_.push_slot::<FormFieldType>(FormField::VT_FIELD_TYPE, field_type, FormFieldType::Text);
  }
  #[inline]
  pub fn add_label(&mut self, label: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_LABEL, label);
  }
  #[inline]
  pub fn add_placeholder(&mut self, placeholder: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_PLACEHOLDER, placeholder);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn add_initial_value(&mut self, initial_value: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_INITIAL_VALUE, initial_value);
  }
  #[inline]
  pub fn add_validations(&mut self, validations: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ValidationRule<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_VALIDATIONS, validations);
  }
  #[inline]
  pub fn add_async_validations(&mut self, async_validations: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AsyncValidation<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_ASYNC_VALIDATIONS, async_validations);
  }
  #[inline]
  pub fn add_options(&mut self, options: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<SelectOption<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_OPTIONS, options);
  }
  #[inline]
  pub fn add_visible_when(&mut self, visible_when: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_VISIBLE_WHEN, visible_when);
  }
  #[inline]
  pub fn add_disabled_when(&mut self, disabled_when: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_DISABLED_WHEN, disabled_when);
  }
  #[inline]
  pub fn add_autocomplete(&mut self, autocomplete: AutocompleteHint) {
    self.fbb_.push_slot::<AutocompleteHint>(FormField::VT_AUTOCOMPLETE, autocomplete, AutocompleteHint::Off);
  }
  #[inline]
  pub fn add_accept(&mut self, accept: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_ACCEPT, accept);
  }
  #[inline]
  pub fn add_max_file_size(&mut self, max_file_size: u32) {
    self.fbb_.push_slot::<u32>(FormField::VT_MAX_FILE_SIZE, max_file_size, 0);
  }
  #[inline]
  pub fn add_multiple(&mut self, multiple: bool) {
    self.fbb_.push_slot::<bool>(FormField::VT_MULTIPLE, multiple, false);
  }
  #[inline]
  pub fn add_step(&mut self, step: f32) {
    self.fbb_.push_slot::<f32>(FormField::VT_STEP, step, 0.0);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormField::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FormFieldBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FormFieldBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FormField<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FormField::VT_NAME,"name");
    self.fbb_.required(o, FormField::VT_LABEL,"label");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FormField<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FormField");
      ds.field("name", &self.name());
      ds.field("field_type", &self.field_type());
      ds.field("label", &self.label());
      ds.field("placeholder", &self.placeholder());
      ds.field("description", &self.description());
      ds.field("initial_value", &self.initial_value());
      ds.field("validations", &self.validations());
      ds.field("async_validations", &self.async_validations());
      ds.field("options", &self.options());
      ds.field("visible_when", &self.visible_when());
      ds.field("disabled_when", &self.disabled_when());
      ds.field("autocomplete", &self.autocomplete());
      ds.field("accept", &self.accept());
      ds.field("max_file_size", &self.max_file_size());
      ds.field("multiple", &self.multiple());
      ds.field("step", &self.step());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum FormSubmissionOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> FormSubmission<'a> {
  pub const VT_ACTION_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_ENCODING: flatbuffers::VOffsetT = 6;
  pub const VT_PROGRESSIVE: flatbuffers::VOffsetT = 8;
  pub const VT_SUCCESS_EVENT: flatbuffers::VOffsetT = 10;
  pub const VT_SUCCESS_STATE_MACHINE: flatbuffers::VOffsetT = 12;
  pub const VT_SUCCESS_REDIRECT: flatbuffers::VOffsetT = 14;
  pub const VT_ERROR_DISPLAY: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FormSubmission { _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 FormSubmissionArgs<'args>
  ) -> flatbuffers::WIPOffset<FormSubmission<'bldr>> {
    let mut builder = FormSubmissionBuilder::new(_fbb);
    if let Some(x) = args.error_display { builder.add_error_display(x); }
    if let Some(x) = args.success_redirect { builder.add_success_redirect(x); }
    if let Some(x) = args.success_state_machine { builder.add_success_state_machine(x); }
    if let Some(x) = args.success_event { builder.add_success_event(x); }
    if let Some(x) = args.action_node_id { builder.add_action_node_id(x); }
    builder.add_progressive(args.progressive);
    builder.add_encoding(args.encoding);
    builder.finish()
  }


  /// ActionNode that handles the submission.
  #[inline]
  pub fn action_node_id(&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>>(FormSubmission::VT_ACTION_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn encoding(&self) -> FormEncoding {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<FormEncoding>(FormSubmission::VT_ENCODING, Some(FormEncoding::Json)).unwrap()}
  }
  /// If true, the form works without JavaScript (native form action).
  #[inline]
  pub fn progressive(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(FormSubmission::VT_PROGRESSIVE, Some(true)).unwrap()}
  }
  /// State machine event to fire on success.
  #[inline]
  pub fn success_event(&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>>(FormSubmission::VT_SUCCESS_EVENT, None)}
  }
  #[inline]
  pub fn success_state_machine(&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>>(FormSubmission::VT_SUCCESS_STATE_MACHINE, None)}
  }
  /// Route to navigate to on success.
  #[inline]
  pub fn success_redirect(&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>>(FormSubmission::VT_SUCCESS_REDIRECT, None)}
  }
  /// How to display server-side errors.
  /// "field" = map errors to individual fields, "summary" = show error list.
  #[inline]
  pub fn error_display(&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>>(FormSubmission::VT_ERROR_DISPLAY, None)}
  }
}

impl flatbuffers::Verifiable for FormSubmission<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("action_node_id", Self::VT_ACTION_NODE_ID, true)?
     .visit_field::<FormEncoding>("encoding", Self::VT_ENCODING, false)?
     .visit_field::<bool>("progressive", Self::VT_PROGRESSIVE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("success_event", Self::VT_SUCCESS_EVENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("success_state_machine", Self::VT_SUCCESS_STATE_MACHINE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("success_redirect", Self::VT_SUCCESS_REDIRECT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("error_display", Self::VT_ERROR_DISPLAY, false)?
     .finish();
    Ok(())
  }
}
pub struct FormSubmissionArgs<'a> {
    pub action_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub encoding: FormEncoding,
    pub progressive: bool,
    pub success_event: Option<flatbuffers::WIPOffset<&'a str>>,
    pub success_state_machine: Option<flatbuffers::WIPOffset<&'a str>>,
    pub success_redirect: Option<flatbuffers::WIPOffset<&'a str>>,
    pub error_display: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for FormSubmissionArgs<'a> {
  #[inline]
  fn default() -> Self {
    FormSubmissionArgs {
      action_node_id: None, // required field
      encoding: FormEncoding::Json,
      progressive: true,
      success_event: None,
      success_state_machine: None,
      success_redirect: None,
      error_display: None,
    }
  }
}

pub struct FormSubmissionBuilder<'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> FormSubmissionBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_action_node_id(&mut self, action_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormSubmission::VT_ACTION_NODE_ID, action_node_id);
  }
  #[inline]
  pub fn add_encoding(&mut self, encoding: FormEncoding) {
    self.fbb_.push_slot::<FormEncoding>(FormSubmission::VT_ENCODING, encoding, FormEncoding::Json);
  }
  #[inline]
  pub fn add_progressive(&mut self, progressive: bool) {
    self.fbb_.push_slot::<bool>(FormSubmission::VT_PROGRESSIVE, progressive, true);
  }
  #[inline]
  pub fn add_success_event(&mut self, success_event: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormSubmission::VT_SUCCESS_EVENT, success_event);
  }
  #[inline]
  pub fn add_success_state_machine(&mut self, success_state_machine: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormSubmission::VT_SUCCESS_STATE_MACHINE, success_state_machine);
  }
  #[inline]
  pub fn add_success_redirect(&mut self, success_redirect: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormSubmission::VT_SUCCESS_REDIRECT, success_redirect);
  }
  #[inline]
  pub fn add_error_display(&mut self, error_display: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormSubmission::VT_ERROR_DISPLAY, error_display);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FormSubmissionBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FormSubmissionBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FormSubmission<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FormSubmission::VT_ACTION_NODE_ID,"action_node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FormSubmission<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FormSubmission");
      ds.field("action_node_id", &self.action_node_id());
      ds.field("encoding", &self.encoding());
      ds.field("progressive", &self.progressive());
      ds.field("success_event", &self.success_event());
      ds.field("success_state_machine", &self.success_state_machine());
      ds.field("success_redirect", &self.success_redirect());
      ds.field("error_display", &self.error_display());
      ds.finish()
  }
}
pub enum FormFieldGroupOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> FormFieldGroup<'a> {
  pub const VT_LABEL: flatbuffers::VOffsetT = 4;
  pub const VT_FIELD_NAMES: flatbuffers::VOffsetT = 6;
  pub const VT_DESCRIPTION: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FormFieldGroup { _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 FormFieldGroupArgs<'args>
  ) -> flatbuffers::WIPOffset<FormFieldGroup<'bldr>> {
    let mut builder = FormFieldGroupBuilder::new(_fbb);
    if let Some(x) = args.description { builder.add_description(x); }
    if let Some(x) = args.field_names { builder.add_field_names(x); }
    if let Some(x) = args.label { builder.add_label(x); }
    builder.finish()
  }


  /// Group label (rendered as <fieldset><legend>).
  #[inline]
  pub fn label(&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>>(FormFieldGroup::VT_LABEL, None).unwrap()}
  }
  /// Field names in this group.
  #[inline]
  pub fn field_names(&self) -> 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>>>>(FormFieldGroup::VT_FIELD_NAMES, None).unwrap()}
  }
  #[inline]
  pub fn description(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormFieldGroup::VT_DESCRIPTION, None)}
  }
}

impl flatbuffers::Verifiable for FormFieldGroup<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("label", Self::VT_LABEL, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("field_names", Self::VT_FIELD_NAMES, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("description", Self::VT_DESCRIPTION, false)?
     .finish();
    Ok(())
  }
}
pub struct FormFieldGroupArgs<'a> {
    pub label: Option<flatbuffers::WIPOffset<&'a str>>,
    pub field_names: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub description: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for FormFieldGroupArgs<'a> {
  #[inline]
  fn default() -> Self {
    FormFieldGroupArgs {
      label: None, // required field
      field_names: None, // required field
      description: None,
    }
  }
}

pub struct FormFieldGroupBuilder<'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> FormFieldGroupBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_label(&mut self, label: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormFieldGroup::VT_LABEL, label);
  }
  #[inline]
  pub fn add_field_names(&mut self, field_names: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormFieldGroup::VT_FIELD_NAMES, field_names);
  }
  #[inline]
  pub fn add_description(&mut self, description: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormFieldGroup::VT_DESCRIPTION, description);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FormFieldGroupBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FormFieldGroupBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FormFieldGroup<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FormFieldGroup::VT_LABEL,"label");
    self.fbb_.required(o, FormFieldGroup::VT_FIELD_NAMES,"field_names");
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> AutosaveConfig<'a> {
  pub const VT_INTERVAL_MS: flatbuffers::VOffsetT = 4;
  pub const VT_STORAGE_KEY: flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AutosaveConfig { _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 AutosaveConfigArgs<'args>
  ) -> flatbuffers::WIPOffset<AutosaveConfig<'bldr>> {
    let mut builder = AutosaveConfigBuilder::new(_fbb);
    if let Some(x) = args.storage_key { builder.add_storage_key(x); }
    builder.add_interval_ms(args.interval_ms);
    builder.finish()
  }


  /// Save interval in ms (0 = save on every change).
  #[inline]
  pub fn interval_ms(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(AutosaveConfig::VT_INTERVAL_MS, Some(5000)).unwrap()}
  }
  /// Storage key for draft persistence.
  #[inline]
  pub fn storage_key(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(AutosaveConfig::VT_STORAGE_KEY, None)}
  }
}

impl flatbuffers::Verifiable for AutosaveConfig<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<u32>("interval_ms", Self::VT_INTERVAL_MS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("storage_key", Self::VT_STORAGE_KEY, false)?
     .finish();
    Ok(())
  }
}
pub struct AutosaveConfigArgs<'a> {
    pub interval_ms: u32,
    pub storage_key: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AutosaveConfigArgs<'a> {
  #[inline]
  fn default() -> Self {
    AutosaveConfigArgs {
      interval_ms: 5000,
      storage_key: None,
    }
  }
}

pub struct AutosaveConfigBuilder<'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> AutosaveConfigBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_interval_ms(&mut self, interval_ms: u32) {
    self.fbb_.push_slot::<u32>(AutosaveConfig::VT_INTERVAL_MS, interval_ms, 5000);
  }
  #[inline]
  pub fn add_storage_key(&mut self, storage_key: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AutosaveConfig::VT_STORAGE_KEY, storage_key);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AutosaveConfigBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AutosaveConfigBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AutosaveConfig<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

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

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

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

impl<'a> FormNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_FIELDS: flatbuffers::VOffsetT = 8;
  pub const VT_FIELD_GROUPS: flatbuffers::VOffsetT = 10;
  pub const VT_CROSS_VALIDATIONS: flatbuffers::VOffsetT = 12;
  pub const VT_VALIDATION_MODE: flatbuffers::VOffsetT = 14;
  pub const VT_SUBMISSION: flatbuffers::VOffsetT = 16;
  pub const VT_INITIAL_VALUES_NODE_ID: flatbuffers::VOffsetT = 18;
  pub const VT_AUTOSAVE: flatbuffers::VOffsetT = 20;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 22;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FormNode { _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 FormNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<FormNode<'bldr>> {
    let mut builder = FormNodeBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    if let Some(x) = args.autosave { builder.add_autosave(x); }
    if let Some(x) = args.initial_values_node_id { builder.add_initial_values_node_id(x); }
    if let Some(x) = args.submission { builder.add_submission(x); }
    if let Some(x) = args.cross_validations { builder.add_cross_validations(x); }
    if let Some(x) = args.field_groups { builder.add_field_groups(x); }
    if let Some(x) = args.fields { builder.add_fields(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_validation_mode(args.validation_mode);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(FormNode::VT_NODE_ID, None).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>>(FormNode::VT_NAME, None)}
  }
  #[inline]
  pub fn fields(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<FormField<'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<FormField>>>>(FormNode::VT_FIELDS, None).unwrap()}
  }
  #[inline]
  pub fn field_groups(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<FormFieldGroup<'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<FormFieldGroup>>>>(FormNode::VT_FIELD_GROUPS, None)}
  }
  #[inline]
  pub fn cross_validations(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CrossFieldValidation<'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<CrossFieldValidation>>>>(FormNode::VT_CROSS_VALIDATIONS, None)}
  }
  #[inline]
  pub fn validation_mode(&self) -> ValidationMode {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ValidationMode>(FormNode::VT_VALIDATION_MODE, Some(ValidationMode::OnBlurThenChange)).unwrap()}
  }
  #[inline]
  pub fn submission(&self) -> FormSubmission<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FormSubmission>>(FormNode::VT_SUBMISSION, None).unwrap()}
  }
  /// Initial values loaded from a DataNode (for edit forms).
  #[inline]
  pub fn initial_values_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormNode::VT_INITIAL_VALUES_NODE_ID, None)}
  }
  /// Draft persistence configuration.
  #[inline]
  pub fn autosave(&self) -> Option<AutosaveConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<AutosaveConfig>>(FormNode::VT_AUTOSAVE, None)}
  }
  /// Accessibility.
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FormNode::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for FormNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<FormField>>>>("fields", Self::VT_FIELDS, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<FormFieldGroup>>>>("field_groups", Self::VT_FIELD_GROUPS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<CrossFieldValidation>>>>("cross_validations", Self::VT_CROSS_VALIDATIONS, false)?
     .visit_field::<ValidationMode>("validation_mode", Self::VT_VALIDATION_MODE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<FormSubmission>>("submission", Self::VT_SUBMISSION, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("initial_values_node_id", Self::VT_INITIAL_VALUES_NODE_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<AutosaveConfig>>("autosave", Self::VT_AUTOSAVE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct FormNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub fields: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<FormField<'a>>>>>,
    pub field_groups: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<FormFieldGroup<'a>>>>>,
    pub cross_validations: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CrossFieldValidation<'a>>>>>,
    pub validation_mode: ValidationMode,
    pub submission: Option<flatbuffers::WIPOffset<FormSubmission<'a>>>,
    pub initial_values_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub autosave: Option<flatbuffers::WIPOffset<AutosaveConfig<'a>>>,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for FormNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    FormNodeArgs {
      node_id: None, // required field
      name: None,
      fields: None, // required field
      field_groups: None,
      cross_validations: None,
      validation_mode: ValidationMode::OnBlurThenChange,
      submission: None, // required field
      initial_values_node_id: None,
      autosave: None,
      semantic_node_id: None,
    }
  }
}

pub struct FormNodeBuilder<'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> FormNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_NAME, name);
  }
  #[inline]
  pub fn add_fields(&mut self, fields: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<FormField<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_FIELDS, fields);
  }
  #[inline]
  pub fn add_field_groups(&mut self, field_groups: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<FormFieldGroup<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_FIELD_GROUPS, field_groups);
  }
  #[inline]
  pub fn add_cross_validations(&mut self, cross_validations: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<CrossFieldValidation<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_CROSS_VALIDATIONS, cross_validations);
  }
  #[inline]
  pub fn add_validation_mode(&mut self, validation_mode: ValidationMode) {
    self.fbb_.push_slot::<ValidationMode>(FormNode::VT_VALIDATION_MODE, validation_mode, ValidationMode::OnBlurThenChange);
  }
  #[inline]
  pub fn add_submission(&mut self, submission: flatbuffers::WIPOffset<FormSubmission<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FormSubmission>>(FormNode::VT_SUBMISSION, submission);
  }
  #[inline]
  pub fn add_initial_values_node_id(&mut self, initial_values_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_INITIAL_VALUES_NODE_ID, initial_values_node_id);
  }
  #[inline]
  pub fn add_autosave(&mut self, autosave: flatbuffers::WIPOffset<AutosaveConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<AutosaveConfig>>(FormNode::VT_AUTOSAVE, autosave);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FormNode::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FormNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FormNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FormNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, FormNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, FormNode::VT_FIELDS,"fields");
    self.fbb_.required(o, FormNode::VT_SUBMISSION,"submission");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FormNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FormNode");
      ds.field("node_id", &self.node_id());
      ds.field("name", &self.name());
      ds.field("fields", &self.fields());
      ds.field("field_groups", &self.field_groups());
      ds.field("cross_validations", &self.cross_validations());
      ds.field("validation_mode", &self.validation_mode());
      ds.field("submission", &self.submission());
      ds.field("initial_values_node_id", &self.initial_values_node_id());
      ds.field("autosave", &self.autosave());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum ViewRootOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ViewRoot<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CHILDREN: flatbuffers::VOffsetT = 6;
  pub const VT_WIDTH: flatbuffers::VOffsetT = 8;
  pub const VT_HEIGHT: flatbuffers::VOffsetT = 10;
  pub const VT_BACKGROUND: flatbuffers::VOffsetT = 12;
  pub const VT_DOCUMENT_LANGUAGE: flatbuffers::VOffsetT = 14;
  pub const VT_TEXT_DIRECTION: flatbuffers::VOffsetT = 16;
  pub const VT_SEMANTIC_NODES: flatbuffers::VOffsetT = 18;
  pub const VT_METADATA: flatbuffers::VOffsetT = 20;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ViewRoot { _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 ViewRootArgs<'args>
  ) -> flatbuffers::WIPOffset<ViewRoot<'bldr>> {
    let mut builder = ViewRootBuilder::new(_fbb);
    if let Some(x) = args.metadata { builder.add_metadata(x); }
    if let Some(x) = args.semantic_nodes { builder.add_semantic_nodes(x); }
    if let Some(x) = args.document_language { builder.add_document_language(x); }
    if let Some(x) = args.background { builder.add_background(x); }
    if let Some(x) = args.height { builder.add_height(x); }
    if let Some(x) = args.width { builder.add_width(x); }
    if let Some(x) = args.children { builder.add_children(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_text_direction(args.text_direction);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(ViewRoot::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn children(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'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<ChildNode>>>>(ViewRoot::VT_CHILDREN, None)}
  }
  #[inline]
  pub fn width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(ViewRoot::VT_WIDTH, None)}
  }
  #[inline]
  pub fn height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(ViewRoot::VT_HEIGHT, None)}
  }
  #[inline]
  pub fn background(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(ViewRoot::VT_BACKGROUND, None)}
  }
  #[inline]
  pub fn document_language(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(ViewRoot::VT_DOCUMENT_LANGUAGE, None)}
  }
  #[inline]
  pub fn text_direction(&self) -> TextDirection {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<TextDirection>(ViewRoot::VT_TEXT_DIRECTION, Some(TextDirection::Ltr)).unwrap()}
  }
  #[inline]
  pub fn semantic_nodes(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SemanticNode<'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<SemanticNode>>>>(ViewRoot::VT_SEMANTIC_NODES, None)}
  }
  #[inline]
  pub fn metadata(&self) -> Option<PageMetadata<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<PageMetadata>>(ViewRoot::VT_METADATA, None)}
  }
}

impl flatbuffers::Verifiable for ViewRoot<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ChildNode>>>>("children", Self::VT_CHILDREN, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("width", Self::VT_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("height", Self::VT_HEIGHT, false)?
     .visit_field::<Color>("background", Self::VT_BACKGROUND, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("document_language", Self::VT_DOCUMENT_LANGUAGE, false)?
     .visit_field::<TextDirection>("text_direction", Self::VT_TEXT_DIRECTION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SemanticNode>>>>("semantic_nodes", Self::VT_SEMANTIC_NODES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<PageMetadata>>("metadata", Self::VT_METADATA, false)?
     .finish();
    Ok(())
  }
}
pub struct ViewRootArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub children: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'a>>>>>,
    pub width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub background: Option<&'a Color>,
    pub document_language: Option<flatbuffers::WIPOffset<&'a str>>,
    pub text_direction: TextDirection,
    pub semantic_nodes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SemanticNode<'a>>>>>,
    pub metadata: Option<flatbuffers::WIPOffset<PageMetadata<'a>>>,
}
impl<'a> Default for ViewRootArgs<'a> {
  #[inline]
  fn default() -> Self {
    ViewRootArgs {
      node_id: None, // required field
      children: None,
      width: None,
      height: None,
      background: None,
      document_language: None,
      text_direction: TextDirection::Ltr,
      semantic_nodes: None,
      metadata: None,
    }
  }
}

pub struct ViewRootBuilder<'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> ViewRootBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ViewRoot::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_children(&mut self, children: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ChildNode<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ViewRoot::VT_CHILDREN, children);
  }
  #[inline]
  pub fn add_width(&mut self, width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(ViewRoot::VT_WIDTH, width);
  }
  #[inline]
  pub fn add_height(&mut self, height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(ViewRoot::VT_HEIGHT, height);
  }
  #[inline]
  pub fn add_background(&mut self, background: &Color) {
    self.fbb_.push_slot_always::<&Color>(ViewRoot::VT_BACKGROUND, background);
  }
  #[inline]
  pub fn add_document_language(&mut self, document_language: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ViewRoot::VT_DOCUMENT_LANGUAGE, document_language);
  }
  #[inline]
  pub fn add_text_direction(&mut self, text_direction: TextDirection) {
    self.fbb_.push_slot::<TextDirection>(ViewRoot::VT_TEXT_DIRECTION, text_direction, TextDirection::Ltr);
  }
  #[inline]
  pub fn add_semantic_nodes(&mut self, semantic_nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<SemanticNode<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ViewRoot::VT_SEMANTIC_NODES, semantic_nodes);
  }
  #[inline]
  pub fn add_metadata(&mut self, metadata: flatbuffers::WIPOffset<PageMetadata<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<PageMetadata>>(ViewRoot::VT_METADATA, metadata);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ViewRootBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ViewRootBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ViewRoot<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ViewRoot::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ViewRoot<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ViewRoot");
      ds.field("node_id", &self.node_id());
      ds.field("children", &self.children());
      ds.field("width", &self.width());
      ds.field("height", &self.height());
      ds.field("background", &self.background());
      ds.field("document_language", &self.document_language());
      ds.field("text_direction", &self.text_direction());
      ds.field("semantic_nodes", &self.semantic_nodes());
      ds.field("metadata", &self.metadata());
      ds.finish()
  }
}
pub enum ContainerOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> Container<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CHILDREN: flatbuffers::VOffsetT = 6;
  pub const VT_LAYOUT: flatbuffers::VOffsetT = 8;
  pub const VT_DIRECTION: flatbuffers::VOffsetT = 10;
  pub const VT_MAIN_ALIGN: flatbuffers::VOffsetT = 12;
  pub const VT_CROSS_ALIGN: flatbuffers::VOffsetT = 14;
  pub const VT_GAP: flatbuffers::VOffsetT = 16;
  pub const VT_PADDING: flatbuffers::VOffsetT = 18;
  pub const VT_WRAP: flatbuffers::VOffsetT = 20;
  pub const VT_GRID_COLUMNS: flatbuffers::VOffsetT = 22;
  pub const VT_GRID_ROWS: flatbuffers::VOffsetT = 24;
  pub const VT_WIDTH: flatbuffers::VOffsetT = 26;
  pub const VT_HEIGHT: flatbuffers::VOffsetT = 28;
  pub const VT_MIN_WIDTH: flatbuffers::VOffsetT = 30;
  pub const VT_MAX_WIDTH: flatbuffers::VOffsetT = 32;
  pub const VT_MIN_HEIGHT: flatbuffers::VOffsetT = 34;
  pub const VT_MAX_HEIGHT: flatbuffers::VOffsetT = 36;
  pub const VT_OVERFLOW_X: flatbuffers::VOffsetT = 38;
  pub const VT_OVERFLOW_Y: flatbuffers::VOffsetT = 40;
  pub const VT_CLIP: flatbuffers::VOffsetT = 42;
  pub const VT_POSITION: flatbuffers::VOffsetT = 44;
  pub const VT_TOP: flatbuffers::VOffsetT = 46;
  pub const VT_RIGHT: flatbuffers::VOffsetT = 48;
  pub const VT_BOTTOM: flatbuffers::VOffsetT = 50;
  pub const VT_LEFT: flatbuffers::VOffsetT = 52;
  pub const VT_Z_INDEX: flatbuffers::VOffsetT = 54;
  pub const VT_OPACITY: flatbuffers::VOffsetT = 56;
  pub const VT_BACKGROUND: flatbuffers::VOffsetT = 58;
  pub const VT_BORDER: flatbuffers::VOffsetT = 60;
  pub const VT_CORNER_RADIUS: flatbuffers::VOffsetT = 62;
  pub const VT_SHADOW: flatbuffers::VOffsetT = 64;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 66;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Container { _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 ContainerArgs<'args>
  ) -> flatbuffers::WIPOffset<Container<'bldr>> {
    let mut builder = ContainerBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    if let Some(x) = args.shadow { builder.add_shadow(x); }
    if let Some(x) = args.corner_radius { builder.add_corner_radius(x); }
    if let Some(x) = args.border { builder.add_border(x); }
    if let Some(x) = args.background { builder.add_background(x); }
    builder.add_opacity(args.opacity);
    builder.add_z_index(args.z_index);
    if let Some(x) = args.left { builder.add_left(x); }
    if let Some(x) = args.bottom { builder.add_bottom(x); }
    if let Some(x) = args.right { builder.add_right(x); }
    if let Some(x) = args.top { builder.add_top(x); }
    if let Some(x) = args.max_height { builder.add_max_height(x); }
    if let Some(x) = args.min_height { builder.add_min_height(x); }
    if let Some(x) = args.max_width { builder.add_max_width(x); }
    if let Some(x) = args.min_width { builder.add_min_width(x); }
    if let Some(x) = args.height { builder.add_height(x); }
    if let Some(x) = args.width { builder.add_width(x); }
    if let Some(x) = args.grid_rows { builder.add_grid_rows(x); }
    if let Some(x) = args.grid_columns { builder.add_grid_columns(x); }
    if let Some(x) = args.padding { builder.add_padding(x); }
    if let Some(x) = args.gap { builder.add_gap(x); }
    if let Some(x) = args.children { builder.add_children(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_position(args.position);
    builder.add_clip(args.clip);
    builder.add_overflow_y(args.overflow_y);
    builder.add_overflow_x(args.overflow_x);
    builder.add_wrap(args.wrap);
    builder.add_cross_align(args.cross_align);
    builder.add_main_align(args.main_align);
    builder.add_direction(args.direction);
    builder.add_layout(args.layout);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(Container::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn children(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'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<ChildNode>>>>(Container::VT_CHILDREN, None)}
  }
  #[inline]
  pub fn layout(&self) -> ContainerLayout {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ContainerLayout>(Container::VT_LAYOUT, Some(ContainerLayout::Stack)).unwrap()}
  }
  #[inline]
  pub fn direction(&self) -> LayoutDirection {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<LayoutDirection>(Container::VT_DIRECTION, Some(LayoutDirection::Column)).unwrap()}
  }
  #[inline]
  pub fn main_align(&self) -> Alignment {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Alignment>(Container::VT_MAIN_ALIGN, Some(Alignment::Start)).unwrap()}
  }
  #[inline]
  pub fn cross_align(&self) -> Alignment {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Alignment>(Container::VT_CROSS_ALIGN, Some(Alignment::Start)).unwrap()}
  }
  #[inline]
  pub fn gap(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_GAP, None)}
  }
  #[inline]
  pub fn padding(&self) -> Option<EdgeInsets<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<EdgeInsets>>(Container::VT_PADDING, None)}
  }
  #[inline]
  pub fn wrap(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Container::VT_WRAP, Some(false)).unwrap()}
  }
  #[inline]
  pub fn grid_columns(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'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<Length>>>>(Container::VT_GRID_COLUMNS, None)}
  }
  #[inline]
  pub fn grid_rows(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'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<Length>>>>(Container::VT_GRID_ROWS, None)}
  }
  #[inline]
  pub fn width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_WIDTH, None)}
  }
  #[inline]
  pub fn height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_HEIGHT, None)}
  }
  #[inline]
  pub fn min_width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_MIN_WIDTH, None)}
  }
  #[inline]
  pub fn max_width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_MAX_WIDTH, None)}
  }
  #[inline]
  pub fn min_height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_MIN_HEIGHT, None)}
  }
  #[inline]
  pub fn max_height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_MAX_HEIGHT, None)}
  }
  #[inline]
  pub fn overflow_x(&self) -> Overflow {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Overflow>(Container::VT_OVERFLOW_X, Some(Overflow::Visible)).unwrap()}
  }
  #[inline]
  pub fn overflow_y(&self) -> Overflow {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Overflow>(Container::VT_OVERFLOW_Y, Some(Overflow::Visible)).unwrap()}
  }
  #[inline]
  pub fn clip(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Container::VT_CLIP, Some(false)).unwrap()}
  }
  #[inline]
  pub fn position(&self) -> Position {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Position>(Container::VT_POSITION, Some(Position::Relative)).unwrap()}
  }
  #[inline]
  pub fn top(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_TOP, None)}
  }
  #[inline]
  pub fn right(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_RIGHT, None)}
  }
  #[inline]
  pub fn bottom(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_BOTTOM, None)}
  }
  #[inline]
  pub fn left(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Container::VT_LEFT, None)}
  }
  #[inline]
  pub fn z_index(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(Container::VT_Z_INDEX, Some(0)).unwrap()}
  }
  #[inline]
  pub fn opacity(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Container::VT_OPACITY, Some(1.0)).unwrap()}
  }
  #[inline]
  pub fn background(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(Container::VT_BACKGROUND, None)}
  }
  #[inline]
  pub fn border(&self) -> Option<BorderSides<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<BorderSides>>(Container::VT_BORDER, None)}
  }
  #[inline]
  pub fn corner_radius(&self) -> Option<CornerRadii<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CornerRadii>>(Container::VT_CORNER_RADIUS, None)}
  }
  #[inline]
  pub fn shadow(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Shadow<'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<Shadow>>>>(Container::VT_SHADOW, None)}
  }
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Container::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for Container<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ChildNode>>>>("children", Self::VT_CHILDREN, false)?
     .visit_field::<ContainerLayout>("layout", Self::VT_LAYOUT, false)?
     .visit_field::<LayoutDirection>("direction", Self::VT_DIRECTION, false)?
     .visit_field::<Alignment>("main_align", Self::VT_MAIN_ALIGN, false)?
     .visit_field::<Alignment>("cross_align", Self::VT_CROSS_ALIGN, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("gap", Self::VT_GAP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<EdgeInsets>>("padding", Self::VT_PADDING, false)?
     .visit_field::<bool>("wrap", Self::VT_WRAP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Length>>>>("grid_columns", Self::VT_GRID_COLUMNS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Length>>>>("grid_rows", Self::VT_GRID_ROWS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("width", Self::VT_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("height", Self::VT_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("min_width", Self::VT_MIN_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("max_width", Self::VT_MAX_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("min_height", Self::VT_MIN_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("max_height", Self::VT_MAX_HEIGHT, false)?
     .visit_field::<Overflow>("overflow_x", Self::VT_OVERFLOW_X, false)?
     .visit_field::<Overflow>("overflow_y", Self::VT_OVERFLOW_Y, false)?
     .visit_field::<bool>("clip", Self::VT_CLIP, false)?
     .visit_field::<Position>("position", Self::VT_POSITION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("top", Self::VT_TOP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("right", Self::VT_RIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("bottom", Self::VT_BOTTOM, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("left", Self::VT_LEFT, false)?
     .visit_field::<i32>("z_index", Self::VT_Z_INDEX, false)?
     .visit_field::<f32>("opacity", Self::VT_OPACITY, false)?
     .visit_field::<Color>("background", Self::VT_BACKGROUND, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<BorderSides>>("border", Self::VT_BORDER, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<CornerRadii>>("corner_radius", Self::VT_CORNER_RADIUS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Shadow>>>>("shadow", Self::VT_SHADOW, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct ContainerArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub children: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'a>>>>>,
    pub layout: ContainerLayout,
    pub direction: LayoutDirection,
    pub main_align: Alignment,
    pub cross_align: Alignment,
    pub gap: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub padding: Option<flatbuffers::WIPOffset<EdgeInsets<'a>>>,
    pub wrap: bool,
    pub grid_columns: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'a>>>>>,
    pub grid_rows: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Length<'a>>>>>,
    pub width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub min_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub max_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub min_height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub max_height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub overflow_x: Overflow,
    pub overflow_y: Overflow,
    pub clip: bool,
    pub position: Position,
    pub top: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub right: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub bottom: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub left: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub z_index: i32,
    pub opacity: f32,
    pub background: Option<&'a Color>,
    pub border: Option<flatbuffers::WIPOffset<BorderSides<'a>>>,
    pub corner_radius: Option<flatbuffers::WIPOffset<CornerRadii<'a>>>,
    pub shadow: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Shadow<'a>>>>>,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ContainerArgs<'a> {
  #[inline]
  fn default() -> Self {
    ContainerArgs {
      node_id: None, // required field
      children: None,
      layout: ContainerLayout::Stack,
      direction: LayoutDirection::Column,
      main_align: Alignment::Start,
      cross_align: Alignment::Start,
      gap: None,
      padding: None,
      wrap: false,
      grid_columns: None,
      grid_rows: None,
      width: None,
      height: None,
      min_width: None,
      max_width: None,
      min_height: None,
      max_height: None,
      overflow_x: Overflow::Visible,
      overflow_y: Overflow::Visible,
      clip: false,
      position: Position::Relative,
      top: None,
      right: None,
      bottom: None,
      left: None,
      z_index: 0,
      opacity: 1.0,
      background: None,
      border: None,
      corner_radius: None,
      shadow: None,
      semantic_node_id: None,
    }
  }
}

pub struct ContainerBuilder<'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> ContainerBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_children(&mut self, children: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ChildNode<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_CHILDREN, children);
  }
  #[inline]
  pub fn add_layout(&mut self, layout: ContainerLayout) {
    self.fbb_.push_slot::<ContainerLayout>(Container::VT_LAYOUT, layout, ContainerLayout::Stack);
  }
  #[inline]
  pub fn add_direction(&mut self, direction: LayoutDirection) {
    self.fbb_.push_slot::<LayoutDirection>(Container::VT_DIRECTION, direction, LayoutDirection::Column);
  }
  #[inline]
  pub fn add_main_align(&mut self, main_align: Alignment) {
    self.fbb_.push_slot::<Alignment>(Container::VT_MAIN_ALIGN, main_align, Alignment::Start);
  }
  #[inline]
  pub fn add_cross_align(&mut self, cross_align: Alignment) {
    self.fbb_.push_slot::<Alignment>(Container::VT_CROSS_ALIGN, cross_align, Alignment::Start);
  }
  #[inline]
  pub fn add_gap(&mut self, gap: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_GAP, gap);
  }
  #[inline]
  pub fn add_padding(&mut self, padding: flatbuffers::WIPOffset<EdgeInsets<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<EdgeInsets>>(Container::VT_PADDING, padding);
  }
  #[inline]
  pub fn add_wrap(&mut self, wrap: bool) {
    self.fbb_.push_slot::<bool>(Container::VT_WRAP, wrap, false);
  }
  #[inline]
  pub fn add_grid_columns(&mut self, grid_columns: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Length<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_GRID_COLUMNS, grid_columns);
  }
  #[inline]
  pub fn add_grid_rows(&mut self, grid_rows: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Length<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_GRID_ROWS, grid_rows);
  }
  #[inline]
  pub fn add_width(&mut self, width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_WIDTH, width);
  }
  #[inline]
  pub fn add_height(&mut self, height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_HEIGHT, height);
  }
  #[inline]
  pub fn add_min_width(&mut self, min_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_MIN_WIDTH, min_width);
  }
  #[inline]
  pub fn add_max_width(&mut self, max_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_MAX_WIDTH, max_width);
  }
  #[inline]
  pub fn add_min_height(&mut self, min_height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_MIN_HEIGHT, min_height);
  }
  #[inline]
  pub fn add_max_height(&mut self, max_height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_MAX_HEIGHT, max_height);
  }
  #[inline]
  pub fn add_overflow_x(&mut self, overflow_x: Overflow) {
    self.fbb_.push_slot::<Overflow>(Container::VT_OVERFLOW_X, overflow_x, Overflow::Visible);
  }
  #[inline]
  pub fn add_overflow_y(&mut self, overflow_y: Overflow) {
    self.fbb_.push_slot::<Overflow>(Container::VT_OVERFLOW_Y, overflow_y, Overflow::Visible);
  }
  #[inline]
  pub fn add_clip(&mut self, clip: bool) {
    self.fbb_.push_slot::<bool>(Container::VT_CLIP, clip, false);
  }
  #[inline]
  pub fn add_position(&mut self, position: Position) {
    self.fbb_.push_slot::<Position>(Container::VT_POSITION, position, Position::Relative);
  }
  #[inline]
  pub fn add_top(&mut self, top: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_TOP, top);
  }
  #[inline]
  pub fn add_right(&mut self, right: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_RIGHT, right);
  }
  #[inline]
  pub fn add_bottom(&mut self, bottom: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_BOTTOM, bottom);
  }
  #[inline]
  pub fn add_left(&mut self, left: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Container::VT_LEFT, left);
  }
  #[inline]
  pub fn add_z_index(&mut self, z_index: i32) {
    self.fbb_.push_slot::<i32>(Container::VT_Z_INDEX, z_index, 0);
  }
  #[inline]
  pub fn add_opacity(&mut self, opacity: f32) {
    self.fbb_.push_slot::<f32>(Container::VT_OPACITY, opacity, 1.0);
  }
  #[inline]
  pub fn add_background(&mut self, background: &Color) {
    self.fbb_.push_slot_always::<&Color>(Container::VT_BACKGROUND, background);
  }
  #[inline]
  pub fn add_border(&mut self, border: flatbuffers::WIPOffset<BorderSides<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<BorderSides>>(Container::VT_BORDER, border);
  }
  #[inline]
  pub fn add_corner_radius(&mut self, corner_radius: flatbuffers::WIPOffset<CornerRadii<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CornerRadii>>(Container::VT_CORNER_RADIUS, corner_radius);
  }
  #[inline]
  pub fn add_shadow(&mut self, shadow: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Shadow<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_SHADOW, shadow);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Container::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ContainerBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ContainerBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Container<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Container::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for Container<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("Container");
      ds.field("node_id", &self.node_id());
      ds.field("children", &self.children());
      ds.field("layout", &self.layout());
      ds.field("direction", &self.direction());
      ds.field("main_align", &self.main_align());
      ds.field("cross_align", &self.cross_align());
      ds.field("gap", &self.gap());
      ds.field("padding", &self.padding());
      ds.field("wrap", &self.wrap());
      ds.field("grid_columns", &self.grid_columns());
      ds.field("grid_rows", &self.grid_rows());
      ds.field("width", &self.width());
      ds.field("height", &self.height());
      ds.field("min_width", &self.min_width());
      ds.field("max_width", &self.max_width());
      ds.field("min_height", &self.min_height());
      ds.field("max_height", &self.max_height());
      ds.field("overflow_x", &self.overflow_x());
      ds.field("overflow_y", &self.overflow_y());
      ds.field("clip", &self.clip());
      ds.field("position", &self.position());
      ds.field("top", &self.top());
      ds.field("right", &self.right());
      ds.field("bottom", &self.bottom());
      ds.field("left", &self.left());
      ds.field("z_index", &self.z_index());
      ds.field("opacity", &self.opacity());
      ds.field("background", &self.background());
      ds.field("border", &self.border());
      ds.field("corner_radius", &self.corner_radius());
      ds.field("shadow", &self.shadow());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum SurfaceOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> Surface<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CHILDREN: flatbuffers::VOffsetT = 6;
  pub const VT_FILL: flatbuffers::VOffsetT = 8;
  pub const VT_STROKE: flatbuffers::VOffsetT = 10;
  pub const VT_STROKE_WIDTH: flatbuffers::VOffsetT = 12;
  pub const VT_CORNER_RADIUS: flatbuffers::VOffsetT = 14;
  pub const VT_SHADOW: flatbuffers::VOffsetT = 16;
  pub const VT_OPACITY: flatbuffers::VOffsetT = 18;
  pub const VT_BORDER: flatbuffers::VOffsetT = 20;
  pub const VT_WIDTH: flatbuffers::VOffsetT = 22;
  pub const VT_HEIGHT: flatbuffers::VOffsetT = 24;
  pub const VT_MIN_WIDTH: flatbuffers::VOffsetT = 26;
  pub const VT_MAX_WIDTH: flatbuffers::VOffsetT = 28;
  pub const VT_MIN_HEIGHT: flatbuffers::VOffsetT = 30;
  pub const VT_MAX_HEIGHT: flatbuffers::VOffsetT = 32;
  pub const VT_PADDING: flatbuffers::VOffsetT = 34;
  pub const VT_DECORATIVE: flatbuffers::VOffsetT = 36;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 38;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    Surface { _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 SurfaceArgs<'args>
  ) -> flatbuffers::WIPOffset<Surface<'bldr>> {
    let mut builder = SurfaceBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    if let Some(x) = args.padding { builder.add_padding(x); }
    if let Some(x) = args.max_height { builder.add_max_height(x); }
    if let Some(x) = args.min_height { builder.add_min_height(x); }
    if let Some(x) = args.max_width { builder.add_max_width(x); }
    if let Some(x) = args.min_width { builder.add_min_width(x); }
    if let Some(x) = args.height { builder.add_height(x); }
    if let Some(x) = args.width { builder.add_width(x); }
    if let Some(x) = args.border { builder.add_border(x); }
    builder.add_opacity(args.opacity);
    if let Some(x) = args.shadow { builder.add_shadow(x); }
    if let Some(x) = args.corner_radius { builder.add_corner_radius(x); }
    if let Some(x) = args.stroke_width { builder.add_stroke_width(x); }
    if let Some(x) = args.stroke { builder.add_stroke(x); }
    if let Some(x) = args.fill { builder.add_fill(x); }
    if let Some(x) = args.children { builder.add_children(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_decorative(args.decorative);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(Surface::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn children(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'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<ChildNode>>>>(Surface::VT_CHILDREN, None)}
  }
  #[inline]
  pub fn fill(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(Surface::VT_FILL, None)}
  }
  #[inline]
  pub fn stroke(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(Surface::VT_STROKE, None)}
  }
  #[inline]
  pub fn stroke_width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_STROKE_WIDTH, None)}
  }
  #[inline]
  pub fn corner_radius(&self) -> Option<CornerRadii<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CornerRadii>>(Surface::VT_CORNER_RADIUS, None)}
  }
  #[inline]
  pub fn shadow(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Shadow<'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<Shadow>>>>(Surface::VT_SHADOW, None)}
  }
  #[inline]
  pub fn opacity(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(Surface::VT_OPACITY, Some(1.0)).unwrap()}
  }
  #[inline]
  pub fn border(&self) -> Option<BorderSides<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<BorderSides>>(Surface::VT_BORDER, None)}
  }
  #[inline]
  pub fn width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_WIDTH, None)}
  }
  #[inline]
  pub fn height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_HEIGHT, None)}
  }
  #[inline]
  pub fn min_width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_MIN_WIDTH, None)}
  }
  #[inline]
  pub fn max_width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_MAX_WIDTH, None)}
  }
  #[inline]
  pub fn min_height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_MIN_HEIGHT, None)}
  }
  #[inline]
  pub fn max_height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(Surface::VT_MAX_HEIGHT, None)}
  }
  #[inline]
  pub fn padding(&self) -> Option<EdgeInsets<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<EdgeInsets>>(Surface::VT_PADDING, None)}
  }
  #[inline]
  pub fn decorative(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Surface::VT_DECORATIVE, Some(false)).unwrap()}
  }
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Surface::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for Surface<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ChildNode>>>>("children", Self::VT_CHILDREN, false)?
     .visit_field::<Color>("fill", Self::VT_FILL, false)?
     .visit_field::<Color>("stroke", Self::VT_STROKE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("stroke_width", Self::VT_STROKE_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<CornerRadii>>("corner_radius", Self::VT_CORNER_RADIUS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Shadow>>>>("shadow", Self::VT_SHADOW, false)?
     .visit_field::<f32>("opacity", Self::VT_OPACITY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<BorderSides>>("border", Self::VT_BORDER, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("width", Self::VT_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("height", Self::VT_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("min_width", Self::VT_MIN_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("max_width", Self::VT_MAX_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("min_height", Self::VT_MIN_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("max_height", Self::VT_MAX_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<EdgeInsets>>("padding", Self::VT_PADDING, false)?
     .visit_field::<bool>("decorative", Self::VT_DECORATIVE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct SurfaceArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub children: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ChildNode<'a>>>>>,
    pub fill: Option<&'a Color>,
    pub stroke: Option<&'a Color>,
    pub stroke_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub corner_radius: Option<flatbuffers::WIPOffset<CornerRadii<'a>>>,
    pub shadow: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Shadow<'a>>>>>,
    pub opacity: f32,
    pub border: Option<flatbuffers::WIPOffset<BorderSides<'a>>>,
    pub width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub min_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub max_width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub min_height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub max_height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub padding: Option<flatbuffers::WIPOffset<EdgeInsets<'a>>>,
    pub decorative: bool,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for SurfaceArgs<'a> {
  #[inline]
  fn default() -> Self {
    SurfaceArgs {
      node_id: None, // required field
      children: None,
      fill: None,
      stroke: None,
      stroke_width: None,
      corner_radius: None,
      shadow: None,
      opacity: 1.0,
      border: None,
      width: None,
      height: None,
      min_width: None,
      max_width: None,
      min_height: None,
      max_height: None,
      padding: None,
      decorative: false,
      semantic_node_id: None,
    }
  }
}

pub struct SurfaceBuilder<'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> SurfaceBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Surface::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_children(&mut self, children: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ChildNode<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Surface::VT_CHILDREN, children);
  }
  #[inline]
  pub fn add_fill(&mut self, fill: &Color) {
    self.fbb_.push_slot_always::<&Color>(Surface::VT_FILL, fill);
  }
  #[inline]
  pub fn add_stroke(&mut self, stroke: &Color) {
    self.fbb_.push_slot_always::<&Color>(Surface::VT_STROKE, stroke);
  }
  #[inline]
  pub fn add_stroke_width(&mut self, stroke_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_STROKE_WIDTH, stroke_width);
  }
  #[inline]
  pub fn add_corner_radius(&mut self, corner_radius: flatbuffers::WIPOffset<CornerRadii<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CornerRadii>>(Surface::VT_CORNER_RADIUS, corner_radius);
  }
  #[inline]
  pub fn add_shadow(&mut self, shadow: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Shadow<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Surface::VT_SHADOW, shadow);
  }
  #[inline]
  pub fn add_opacity(&mut self, opacity: f32) {
    self.fbb_.push_slot::<f32>(Surface::VT_OPACITY, opacity, 1.0);
  }
  #[inline]
  pub fn add_border(&mut self, border: flatbuffers::WIPOffset<BorderSides<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<BorderSides>>(Surface::VT_BORDER, border);
  }
  #[inline]
  pub fn add_width(&mut self, width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_WIDTH, width);
  }
  #[inline]
  pub fn add_height(&mut self, height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_HEIGHT, height);
  }
  #[inline]
  pub fn add_min_width(&mut self, min_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_MIN_WIDTH, min_width);
  }
  #[inline]
  pub fn add_max_width(&mut self, max_width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_MAX_WIDTH, max_width);
  }
  #[inline]
  pub fn add_min_height(&mut self, min_height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_MIN_HEIGHT, min_height);
  }
  #[inline]
  pub fn add_max_height(&mut self, max_height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(Surface::VT_MAX_HEIGHT, max_height);
  }
  #[inline]
  pub fn add_padding(&mut self, padding: flatbuffers::WIPOffset<EdgeInsets<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<EdgeInsets>>(Surface::VT_PADDING, padding);
  }
  #[inline]
  pub fn add_decorative(&mut self, decorative: bool) {
    self.fbb_.push_slot::<bool>(Surface::VT_DECORATIVE, decorative, false);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Surface::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SurfaceBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SurfaceBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<Surface<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Surface::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for Surface<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("Surface");
      ds.field("node_id", &self.node_id());
      ds.field("children", &self.children());
      ds.field("fill", &self.fill());
      ds.field("stroke", &self.stroke());
      ds.field("stroke_width", &self.stroke_width());
      ds.field("corner_radius", &self.corner_radius());
      ds.field("shadow", &self.shadow());
      ds.field("opacity", &self.opacity());
      ds.field("border", &self.border());
      ds.field("width", &self.width());
      ds.field("height", &self.height());
      ds.field("min_width", &self.min_width());
      ds.field("max_width", &self.max_width());
      ds.field("min_height", &self.min_height());
      ds.field("max_height", &self.max_height());
      ds.field("padding", &self.padding());
      ds.field("decorative", &self.decorative());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum TextNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> TextNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CONTENT: flatbuffers::VOffsetT = 6;
  pub const VT_CONTENT_BINDING: flatbuffers::VOffsetT = 8;
  pub const VT_LOCALIZED_CONTENT: flatbuffers::VOffsetT = 10;
  pub const VT_FONT_FAMILY: flatbuffers::VOffsetT = 12;
  pub const VT_FONT_SIZE: flatbuffers::VOffsetT = 14;
  pub const VT_FONT_WEIGHT: flatbuffers::VOffsetT = 16;
  pub const VT_LINE_HEIGHT: flatbuffers::VOffsetT = 18;
  pub const VT_LETTER_SPACING: flatbuffers::VOffsetT = 20;
  pub const VT_TEXT_ALIGN: flatbuffers::VOffsetT = 22;
  pub const VT_TEXT_OVERFLOW: flatbuffers::VOffsetT = 24;
  pub const VT_TEXT_DECORATION: flatbuffers::VOffsetT = 26;
  pub const VT_MAX_LINES: flatbuffers::VOffsetT = 28;
  pub const VT_COLOR: flatbuffers::VOffsetT = 30;
  pub const VT_OPACITY: flatbuffers::VOffsetT = 32;
  pub const VT_HEADING_LEVEL: flatbuffers::VOffsetT = 34;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 36;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    TextNode { _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 TextNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<TextNode<'bldr>> {
    let mut builder = TextNodeBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    builder.add_opacity(args.opacity);
    if let Some(x) = args.color { builder.add_color(x); }
    builder.add_max_lines(args.max_lines);
    if let Some(x) = args.letter_spacing { builder.add_letter_spacing(x); }
    builder.add_line_height(args.line_height);
    if let Some(x) = args.font_size { builder.add_font_size(x); }
    if let Some(x) = args.font_family { builder.add_font_family(x); }
    if let Some(x) = args.localized_content { builder.add_localized_content(x); }
    if let Some(x) = args.content_binding { builder.add_content_binding(x); }
    if let Some(x) = args.content { builder.add_content(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_font_weight(args.font_weight);
    builder.add_heading_level(args.heading_level);
    builder.add_text_decoration(args.text_decoration);
    builder.add_text_overflow(args.text_overflow);
    builder.add_text_align(args.text_align);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(TextNode::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn content(&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>>(TextNode::VT_CONTENT, None)}
  }
  #[inline]
  pub fn content_binding(&self) -> Option<DataBinding<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<DataBinding>>(TextNode::VT_CONTENT_BINDING, None)}
  }
  #[inline]
  pub fn localized_content(&self) -> Option<LocalizedString<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<LocalizedString>>(TextNode::VT_LOCALIZED_CONTENT, None)}
  }
  #[inline]
  pub fn font_family(&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>>(TextNode::VT_FONT_FAMILY, None)}
  }
  #[inline]
  pub fn font_size(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(TextNode::VT_FONT_SIZE, None)}
  }
  #[inline]
  pub fn font_weight(&self) -> FontWeight {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<FontWeight>(TextNode::VT_FONT_WEIGHT, Some(FontWeight::Regular)).unwrap()}
  }
  #[inline]
  pub fn line_height(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(TextNode::VT_LINE_HEIGHT, Some(1.5)).unwrap()}
  }
  #[inline]
  pub fn letter_spacing(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(TextNode::VT_LETTER_SPACING, None)}
  }
  #[inline]
  pub fn text_align(&self) -> TextAlign {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<TextAlign>(TextNode::VT_TEXT_ALIGN, Some(TextAlign::Start)).unwrap()}
  }
  #[inline]
  pub fn text_overflow(&self) -> TextOverflow {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<TextOverflow>(TextNode::VT_TEXT_OVERFLOW, Some(TextOverflow::Clip)).unwrap()}
  }
  #[inline]
  pub fn text_decoration(&self) -> TextDecoration {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<TextDecoration>(TextNode::VT_TEXT_DECORATION, Some(TextDecoration::None)).unwrap()}
  }
  #[inline]
  pub fn max_lines(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(TextNode::VT_MAX_LINES, Some(0)).unwrap()}
  }
  #[inline]
  pub fn color(&self) -> Option<&'a Color> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Color>(TextNode::VT_COLOR, None)}
  }
  #[inline]
  pub fn opacity(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(TextNode::VT_OPACITY, Some(1.0)).unwrap()}
  }
  #[inline]
  pub fn heading_level(&self) -> i8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i8>(TextNode::VT_HEADING_LEVEL, Some(0)).unwrap()}
  }
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(TextNode::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for TextNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("content", Self::VT_CONTENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<DataBinding>>("content_binding", Self::VT_CONTENT_BINDING, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<LocalizedString>>("localized_content", Self::VT_LOCALIZED_CONTENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("font_family", Self::VT_FONT_FAMILY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("font_size", Self::VT_FONT_SIZE, false)?
     .visit_field::<FontWeight>("font_weight", Self::VT_FONT_WEIGHT, false)?
     .visit_field::<f32>("line_height", Self::VT_LINE_HEIGHT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("letter_spacing", Self::VT_LETTER_SPACING, false)?
     .visit_field::<TextAlign>("text_align", Self::VT_TEXT_ALIGN, false)?
     .visit_field::<TextOverflow>("text_overflow", Self::VT_TEXT_OVERFLOW, false)?
     .visit_field::<TextDecoration>("text_decoration", Self::VT_TEXT_DECORATION, false)?
     .visit_field::<i32>("max_lines", Self::VT_MAX_LINES, false)?
     .visit_field::<Color>("color", Self::VT_COLOR, false)?
     .visit_field::<f32>("opacity", Self::VT_OPACITY, false)?
     .visit_field::<i8>("heading_level", Self::VT_HEADING_LEVEL, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct TextNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub content: Option<flatbuffers::WIPOffset<&'a str>>,
    pub content_binding: Option<flatbuffers::WIPOffset<DataBinding<'a>>>,
    pub localized_content: Option<flatbuffers::WIPOffset<LocalizedString<'a>>>,
    pub font_family: Option<flatbuffers::WIPOffset<&'a str>>,
    pub font_size: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub font_weight: FontWeight,
    pub line_height: f32,
    pub letter_spacing: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub text_align: TextAlign,
    pub text_overflow: TextOverflow,
    pub text_decoration: TextDecoration,
    pub max_lines: i32,
    pub color: Option<&'a Color>,
    pub opacity: f32,
    pub heading_level: i8,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for TextNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    TextNodeArgs {
      node_id: None, // required field
      content: None,
      content_binding: None,
      localized_content: None,
      font_family: None,
      font_size: None,
      font_weight: FontWeight::Regular,
      line_height: 1.5,
      letter_spacing: None,
      text_align: TextAlign::Start,
      text_overflow: TextOverflow::Clip,
      text_decoration: TextDecoration::None,
      max_lines: 0,
      color: None,
      opacity: 1.0,
      heading_level: 0,
      semantic_node_id: None,
    }
  }
}

pub struct TextNodeBuilder<'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> TextNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TextNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_content(&mut self, content: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TextNode::VT_CONTENT, content);
  }
  #[inline]
  pub fn add_content_binding(&mut self, content_binding: flatbuffers::WIPOffset<DataBinding<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<DataBinding>>(TextNode::VT_CONTENT_BINDING, content_binding);
  }
  #[inline]
  pub fn add_localized_content(&mut self, localized_content: flatbuffers::WIPOffset<LocalizedString<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<LocalizedString>>(TextNode::VT_LOCALIZED_CONTENT, localized_content);
  }
  #[inline]
  pub fn add_font_family(&mut self, font_family: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TextNode::VT_FONT_FAMILY, font_family);
  }
  #[inline]
  pub fn add_font_size(&mut self, font_size: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(TextNode::VT_FONT_SIZE, font_size);
  }
  #[inline]
  pub fn add_font_weight(&mut self, font_weight: FontWeight) {
    self.fbb_.push_slot::<FontWeight>(TextNode::VT_FONT_WEIGHT, font_weight, FontWeight::Regular);
  }
  #[inline]
  pub fn add_line_height(&mut self, line_height: f32) {
    self.fbb_.push_slot::<f32>(TextNode::VT_LINE_HEIGHT, line_height, 1.5);
  }
  #[inline]
  pub fn add_letter_spacing(&mut self, letter_spacing: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(TextNode::VT_LETTER_SPACING, letter_spacing);
  }
  #[inline]
  pub fn add_text_align(&mut self, text_align: TextAlign) {
    self.fbb_.push_slot::<TextAlign>(TextNode::VT_TEXT_ALIGN, text_align, TextAlign::Start);
  }
  #[inline]
  pub fn add_text_overflow(&mut self, text_overflow: TextOverflow) {
    self.fbb_.push_slot::<TextOverflow>(TextNode::VT_TEXT_OVERFLOW, text_overflow, TextOverflow::Clip);
  }
  #[inline]
  pub fn add_text_decoration(&mut self, text_decoration: TextDecoration) {
    self.fbb_.push_slot::<TextDecoration>(TextNode::VT_TEXT_DECORATION, text_decoration, TextDecoration::None);
  }
  #[inline]
  pub fn add_max_lines(&mut self, max_lines: i32) {
    self.fbb_.push_slot::<i32>(TextNode::VT_MAX_LINES, max_lines, 0);
  }
  #[inline]
  pub fn add_color(&mut self, color: &Color) {
    self.fbb_.push_slot_always::<&Color>(TextNode::VT_COLOR, color);
  }
  #[inline]
  pub fn add_opacity(&mut self, opacity: f32) {
    self.fbb_.push_slot::<f32>(TextNode::VT_OPACITY, opacity, 1.0);
  }
  #[inline]
  pub fn add_heading_level(&mut self, heading_level: i8) {
    self.fbb_.push_slot::<i8>(TextNode::VT_HEADING_LEVEL, heading_level, 0);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(TextNode::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TextNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    TextNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<TextNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, TextNode::VT_NODE_ID,"node_id");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for TextNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("TextNode");
      ds.field("node_id", &self.node_id());
      ds.field("content", &self.content());
      ds.field("content_binding", &self.content_binding());
      ds.field("localized_content", &self.localized_content());
      ds.field("font_family", &self.font_family());
      ds.field("font_size", &self.font_size());
      ds.field("font_weight", &self.font_weight());
      ds.field("line_height", &self.line_height());
      ds.field("letter_spacing", &self.letter_spacing());
      ds.field("text_align", &self.text_align());
      ds.field("text_overflow", &self.text_overflow());
      ds.field("text_decoration", &self.text_decoration());
      ds.field("max_lines", &self.max_lines());
      ds.field("color", &self.color());
      ds.field("opacity", &self.opacity());
      ds.field("heading_level", &self.heading_level());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum MediaNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> MediaNode<'a> {
  pub const VT_NODE_ID: flatbuffers::VOffsetT = 4;
  pub const VT_MEDIA_TYPE: flatbuffers::VOffsetT = 6;
  pub const VT_SRC: flatbuffers::VOffsetT = 8;
  pub const VT_ALT: flatbuffers::VOffsetT = 10;
  pub const VT_WIDTH: flatbuffers::VOffsetT = 12;
  pub const VT_HEIGHT: flatbuffers::VOffsetT = 14;
  pub const VT_ASPECT_RATIO: flatbuffers::VOffsetT = 16;
  pub const VT_OBJECT_FIT: flatbuffers::VOffsetT = 18;
  pub const VT_LOADING: flatbuffers::VOffsetT = 20;
  pub const VT_CORNER_RADIUS: flatbuffers::VOffsetT = 22;
  pub const VT_OPACITY: flatbuffers::VOffsetT = 24;
  pub const VT_SRCSET_WIDTHS: flatbuffers::VOffsetT = 26;
  pub const VT_SIZES: flatbuffers::VOffsetT = 28;
  pub const VT_DECORATIVE: flatbuffers::VOffsetT = 30;
  pub const VT_ABOVE_FOLD: flatbuffers::VOffsetT = 32;
  pub const VT_SEMANTIC_NODE_ID: flatbuffers::VOffsetT = 34;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    MediaNode { _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 MediaNodeArgs<'args>
  ) -> flatbuffers::WIPOffset<MediaNode<'bldr>> {
    let mut builder = MediaNodeBuilder::new(_fbb);
    if let Some(x) = args.semantic_node_id { builder.add_semantic_node_id(x); }
    if let Some(x) = args.sizes { builder.add_sizes(x); }
    if let Some(x) = args.srcset_widths { builder.add_srcset_widths(x); }
    builder.add_opacity(args.opacity);
    if let Some(x) = args.corner_radius { builder.add_corner_radius(x); }
    builder.add_aspect_ratio(args.aspect_ratio);
    if let Some(x) = args.height { builder.add_height(x); }
    if let Some(x) = args.width { builder.add_width(x); }
    if let Some(x) = args.alt { builder.add_alt(x); }
    if let Some(x) = args.src { builder.add_src(x); }
    if let Some(x) = args.node_id { builder.add_node_id(x); }
    builder.add_above_fold(args.above_fold);
    builder.add_decorative(args.decorative);
    builder.add_loading(args.loading);
    builder.add_object_fit(args.object_fit);
    builder.add_media_type(args.media_type);
    builder.finish()
  }


  #[inline]
  pub fn node_id(&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>>(MediaNode::VT_NODE_ID, None).unwrap()}
  }
  #[inline]
  pub fn media_type(&self) -> MediaType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<MediaType>(MediaNode::VT_MEDIA_TYPE, Some(MediaType::Image)).unwrap()}
  }
  #[inline]
  pub fn src(&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>>(MediaNode::VT_SRC, None).unwrap()}
  }
  #[inline]
  pub fn alt(&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>>(MediaNode::VT_ALT, None)}
  }
  #[inline]
  pub fn width(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(MediaNode::VT_WIDTH, None)}
  }
  #[inline]
  pub fn height(&self) -> Option<Length<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<Length>>(MediaNode::VT_HEIGHT, None)}
  }
  #[inline]
  pub fn aspect_ratio(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(MediaNode::VT_ASPECT_RATIO, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn object_fit(&self) -> ObjectFit {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ObjectFit>(MediaNode::VT_OBJECT_FIT, Some(ObjectFit::Cover)).unwrap()}
  }
  #[inline]
  pub fn loading(&self) -> LoadingStrategy {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<LoadingStrategy>(MediaNode::VT_LOADING, Some(LoadingStrategy::Lazy)).unwrap()}
  }
  #[inline]
  pub fn corner_radius(&self) -> Option<CornerRadii<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CornerRadii>>(MediaNode::VT_CORNER_RADIUS, None)}
  }
  #[inline]
  pub fn opacity(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(MediaNode::VT_OPACITY, Some(1.0)).unwrap()}
  }
  #[inline]
  pub fn srcset_widths(&self) -> Option<flatbuffers::Vector<'a, i32>> {
    // 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, i32>>>(MediaNode::VT_SRCSET_WIDTHS, None)}
  }
  #[inline]
  pub fn sizes(&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>>(MediaNode::VT_SIZES, None)}
  }
  #[inline]
  pub fn decorative(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(MediaNode::VT_DECORATIVE, Some(false)).unwrap()}
  }
  #[inline]
  pub fn above_fold(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(MediaNode::VT_ABOVE_FOLD, Some(false)).unwrap()}
  }
  #[inline]
  pub fn semantic_node_id(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(MediaNode::VT_SEMANTIC_NODE_ID, None)}
  }
}

impl flatbuffers::Verifiable for MediaNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("node_id", Self::VT_NODE_ID, true)?
     .visit_field::<MediaType>("media_type", Self::VT_MEDIA_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("src", Self::VT_SRC, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("alt", Self::VT_ALT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("width", Self::VT_WIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<Length>>("height", Self::VT_HEIGHT, false)?
     .visit_field::<f32>("aspect_ratio", Self::VT_ASPECT_RATIO, false)?
     .visit_field::<ObjectFit>("object_fit", Self::VT_OBJECT_FIT, false)?
     .visit_field::<LoadingStrategy>("loading", Self::VT_LOADING, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<CornerRadii>>("corner_radius", Self::VT_CORNER_RADIUS, false)?
     .visit_field::<f32>("opacity", Self::VT_OPACITY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>("srcset_widths", Self::VT_SRCSET_WIDTHS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("sizes", Self::VT_SIZES, false)?
     .visit_field::<bool>("decorative", Self::VT_DECORATIVE, false)?
     .visit_field::<bool>("above_fold", Self::VT_ABOVE_FOLD, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("semantic_node_id", Self::VT_SEMANTIC_NODE_ID, false)?
     .finish();
    Ok(())
  }
}
pub struct MediaNodeArgs<'a> {
    pub node_id: Option<flatbuffers::WIPOffset<&'a str>>,
    pub media_type: MediaType,
    pub src: Option<flatbuffers::WIPOffset<&'a str>>,
    pub alt: Option<flatbuffers::WIPOffset<&'a str>>,
    pub width: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub height: Option<flatbuffers::WIPOffset<Length<'a>>>,
    pub aspect_ratio: f32,
    pub object_fit: ObjectFit,
    pub loading: LoadingStrategy,
    pub corner_radius: Option<flatbuffers::WIPOffset<CornerRadii<'a>>>,
    pub opacity: f32,
    pub srcset_widths: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i32>>>,
    pub sizes: Option<flatbuffers::WIPOffset<&'a str>>,
    pub decorative: bool,
    pub above_fold: bool,
    pub semantic_node_id: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for MediaNodeArgs<'a> {
  #[inline]
  fn default() -> Self {
    MediaNodeArgs {
      node_id: None, // required field
      media_type: MediaType::Image,
      src: None, // required field
      alt: None,
      width: None,
      height: None,
      aspect_ratio: 0.0,
      object_fit: ObjectFit::Cover,
      loading: LoadingStrategy::Lazy,
      corner_radius: None,
      opacity: 1.0,
      srcset_widths: None,
      sizes: None,
      decorative: false,
      above_fold: false,
      semantic_node_id: None,
    }
  }
}

pub struct MediaNodeBuilder<'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> MediaNodeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_node_id(&mut self, node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_NODE_ID, node_id);
  }
  #[inline]
  pub fn add_media_type(&mut self, media_type: MediaType) {
    self.fbb_.push_slot::<MediaType>(MediaNode::VT_MEDIA_TYPE, media_type, MediaType::Image);
  }
  #[inline]
  pub fn add_src(&mut self, src: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_SRC, src);
  }
  #[inline]
  pub fn add_alt(&mut self, alt: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_ALT, alt);
  }
  #[inline]
  pub fn add_width(&mut self, width: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(MediaNode::VT_WIDTH, width);
  }
  #[inline]
  pub fn add_height(&mut self, height: flatbuffers::WIPOffset<Length<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Length>>(MediaNode::VT_HEIGHT, height);
  }
  #[inline]
  pub fn add_aspect_ratio(&mut self, aspect_ratio: f32) {
    self.fbb_.push_slot::<f32>(MediaNode::VT_ASPECT_RATIO, aspect_ratio, 0.0);
  }
  #[inline]
  pub fn add_object_fit(&mut self, object_fit: ObjectFit) {
    self.fbb_.push_slot::<ObjectFit>(MediaNode::VT_OBJECT_FIT, object_fit, ObjectFit::Cover);
  }
  #[inline]
  pub fn add_loading(&mut self, loading: LoadingStrategy) {
    self.fbb_.push_slot::<LoadingStrategy>(MediaNode::VT_LOADING, loading, LoadingStrategy::Lazy);
  }
  #[inline]
  pub fn add_corner_radius(&mut self, corner_radius: flatbuffers::WIPOffset<CornerRadii<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CornerRadii>>(MediaNode::VT_CORNER_RADIUS, corner_radius);
  }
  #[inline]
  pub fn add_opacity(&mut self, opacity: f32) {
    self.fbb_.push_slot::<f32>(MediaNode::VT_OPACITY, opacity, 1.0);
  }
  #[inline]
  pub fn add_srcset_widths(&mut self, srcset_widths: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_SRCSET_WIDTHS, srcset_widths);
  }
  #[inline]
  pub fn add_sizes(&mut self, sizes: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_SIZES, sizes);
  }
  #[inline]
  pub fn add_decorative(&mut self, decorative: bool) {
    self.fbb_.push_slot::<bool>(MediaNode::VT_DECORATIVE, decorative, false);
  }
  #[inline]
  pub fn add_above_fold(&mut self, above_fold: bool) {
    self.fbb_.push_slot::<bool>(MediaNode::VT_ABOVE_FOLD, above_fold, false);
  }
  #[inline]
  pub fn add_semantic_node_id(&mut self, semantic_node_id: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MediaNode::VT_SEMANTIC_NODE_ID, semantic_node_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> MediaNodeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    MediaNodeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<MediaNode<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, MediaNode::VT_NODE_ID,"node_id");
    self.fbb_.required(o, MediaNode::VT_SRC,"src");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for MediaNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("MediaNode");
      ds.field("node_id", &self.node_id());
      ds.field("media_type", &self.media_type());
      ds.field("src", &self.src());
      ds.field("alt", &self.alt());
      ds.field("width", &self.width());
      ds.field("height", &self.height());
      ds.field("aspect_ratio", &self.aspect_ratio());
      ds.field("object_fit", &self.object_fit());
      ds.field("loading", &self.loading());
      ds.field("corner_radius", &self.corner_radius());
      ds.field("opacity", &self.opacity());
      ds.field("srcset_widths", &self.srcset_widths());
      ds.field("sizes", &self.sizes());
      ds.field("decorative", &self.decorative());
      ds.field("above_fold", &self.above_fold());
      ds.field("semantic_node_id", &self.semantic_node_id());
      ds.finish()
  }
}
pub enum ChildNodeOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ChildNode<'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 {
    ChildNode { _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 ChildNodeArgs
  ) -> flatbuffers::WIPOffset<ChildNode<'bldr>> {
    let mut builder = ChildNodeBuilder::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) -> ChildUnion {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<ChildUnion>(ChildNode::VT_VALUE_TYPE, Some(ChildUnion::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>>>(ChildNode::VT_VALUE, None)}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn value_as_container(&self) -> Option<Container<'a>> {
    if self.value_type() == ChildUnion::Container {
      self.value().map(|t| {
       // Safety:
       // Created from a valid Table for this object
       // Which contains a valid union in this slot
       unsafe { Container::init_from_table(t) }
     })
    } else {
      None
    }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

impl flatbuffers::Verifiable for ChildNode<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_union::<ChildUnion, _>("value_type", Self::VT_VALUE_TYPE, "value", Self::VT_VALUE, false, |key, v, pos| {
        match key {
          ChildUnion::Container => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Container>>("ChildUnion::Container", pos),
          ChildUnion::Surface => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Surface>>("ChildUnion::Surface", pos),
          ChildUnion::TextNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<TextNode>>("ChildUnion::TextNode", pos),
          ChildUnion::MediaNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<MediaNode>>("ChildUnion::MediaNode", pos),
          ChildUnion::StateMachine => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StateMachine>>("ChildUnion::StateMachine", pos),
          ChildUnion::DataNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<DataNode>>("ChildUnion::DataNode", pos),
          ChildUnion::ComputeNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ComputeNode>>("ChildUnion::ComputeNode", pos),
          ChildUnion::EffectNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<EffectNode>>("ChildUnion::EffectNode", pos),
          ChildUnion::ContextNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ContextNode>>("ChildUnion::ContextNode", pos),
          ChildUnion::AnimationTransition => v.verify_union_variant::<flatbuffers::ForwardsUOffset<AnimationTransition>>("ChildUnion::AnimationTransition", pos),
          ChildUnion::Sequence => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Sequence>>("ChildUnion::Sequence", pos),
          ChildUnion::GestureHandler => v.verify_union_variant::<flatbuffers::ForwardsUOffset<GestureHandler>>("ChildUnion::GestureHandler", pos),
          ChildUnion::ScrollBinding => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ScrollBinding>>("ChildUnion::ScrollBinding", pos),
          ChildUnion::PhysicsBody => v.verify_union_variant::<flatbuffers::ForwardsUOffset<PhysicsBody>>("ChildUnion::PhysicsBody", pos),
          ChildUnion::RouteMap => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RouteMap>>("ChildUnion::RouteMap", pos),
          ChildUnion::SemanticNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SemanticNode>>("ChildUnion::SemanticNode", pos),
          ChildUnion::LiveRegion => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LiveRegion>>("ChildUnion::LiveRegion", pos),
          ChildUnion::FocusTrap => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FocusTrap>>("ChildUnion::FocusTrap", pos),
          ChildUnion::ThemeNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ThemeNode>>("ChildUnion::ThemeNode", pos),
          ChildUnion::PersonalizationSlot => v.verify_union_variant::<flatbuffers::ForwardsUOffset<PersonalizationSlot>>("ChildUnion::PersonalizationSlot", pos),
          ChildUnion::ResponsiveRule => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ResponsiveRule>>("ChildUnion::ResponsiveRule", pos),
          ChildUnion::ActionNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ActionNode>>("ChildUnion::ActionNode", pos),
          ChildUnion::SubscriptionNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SubscriptionNode>>("ChildUnion::SubscriptionNode", pos),
          ChildUnion::AuthContextNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<AuthContextNode>>("ChildUnion::AuthContextNode", pos),
          ChildUnion::ContentSlot => v.verify_union_variant::<flatbuffers::ForwardsUOffset<ContentSlot>>("ChildUnion::ContentSlot", pos),
          ChildUnion::RichTextNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RichTextNode>>("ChildUnion::RichTextNode", pos),
          ChildUnion::FormNode => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FormNode>>("ChildUnion::FormNode", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct ChildNodeArgs {
    pub value_type: ChildUnion,
    pub value: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for ChildNodeArgs {
  #[inline]
  fn default() -> Self {
    ChildNodeArgs {
      value_type: ChildUnion::NONE,
      value: None,
    }
  }
}

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

impl core::fmt::Debug for ChildNode<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ChildNode");
      ds.field("value_type", &self.value_type());
      match self.value_type() {
        ChildUnion::Container => {
          if let Some(x) = self.value_as_container() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::Surface => {
          if let Some(x) = self.value_as_surface() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::TextNode => {
          if let Some(x) = self.value_as_text_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::MediaNode => {
          if let Some(x) = self.value_as_media_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::StateMachine => {
          if let Some(x) = self.value_as_state_machine() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::DataNode => {
          if let Some(x) = self.value_as_data_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ComputeNode => {
          if let Some(x) = self.value_as_compute_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::EffectNode => {
          if let Some(x) = self.value_as_effect_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ContextNode => {
          if let Some(x) = self.value_as_context_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::AnimationTransition => {
          if let Some(x) = self.value_as_animation_transition() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::Sequence => {
          if let Some(x) = self.value_as_sequence() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::GestureHandler => {
          if let Some(x) = self.value_as_gesture_handler() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ScrollBinding => {
          if let Some(x) = self.value_as_scroll_binding() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::PhysicsBody => {
          if let Some(x) = self.value_as_physics_body() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::RouteMap => {
          if let Some(x) = self.value_as_route_map() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::SemanticNode => {
          if let Some(x) = self.value_as_semantic_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::LiveRegion => {
          if let Some(x) = self.value_as_live_region() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::FocusTrap => {
          if let Some(x) = self.value_as_focus_trap() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ThemeNode => {
          if let Some(x) = self.value_as_theme_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::PersonalizationSlot => {
          if let Some(x) = self.value_as_personalization_slot() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ResponsiveRule => {
          if let Some(x) = self.value_as_responsive_rule() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ActionNode => {
          if let Some(x) = self.value_as_action_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::SubscriptionNode => {
          if let Some(x) = self.value_as_subscription_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::AuthContextNode => {
          if let Some(x) = self.value_as_auth_context_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::ContentSlot => {
          if let Some(x) = self.value_as_content_slot() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::RichTextNode => {
          if let Some(x) = self.value_as_rich_text_node() {
            ds.field("value", &x)
          } else {
            ds.field("value", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        ChildUnion::FormNode => {
          if let Some(x) = self.value_as_form_node() {
            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 VoceDocumentOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> VoceDocument<'a> {
  pub const VT_SCHEMA_VERSION_MAJOR: flatbuffers::VOffsetT = 4;
  pub const VT_SCHEMA_VERSION_MINOR: flatbuffers::VOffsetT = 6;
  pub const VT_ROOT: flatbuffers::VOffsetT = 8;
  pub const VT_ROUTES: flatbuffers::VOffsetT = 10;
  pub const VT_THEME: flatbuffers::VOffsetT = 12;
  pub const VT_ALTERNATE_THEMES: flatbuffers::VOffsetT = 14;
  pub const VT_AUTH: flatbuffers::VOffsetT = 16;
  pub const VT_I18N: flatbuffers::VOffsetT = 18;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    VoceDocument { _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 VoceDocumentArgs<'args>
  ) -> flatbuffers::WIPOffset<VoceDocument<'bldr>> {
    let mut builder = VoceDocumentBuilder::new(_fbb);
    if let Some(x) = args.i18n { builder.add_i18n(x); }
    if let Some(x) = args.auth { builder.add_auth(x); }
    if let Some(x) = args.alternate_themes { builder.add_alternate_themes(x); }
    if let Some(x) = args.theme { builder.add_theme(x); }
    if let Some(x) = args.routes { builder.add_routes(x); }
    if let Some(x) = args.root { builder.add_root(x); }
    builder.add_schema_version_minor(args.schema_version_minor);
    builder.add_schema_version_major(args.schema_version_major);
    builder.finish()
  }


  #[inline]
  pub fn schema_version_major(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(VoceDocument::VT_SCHEMA_VERSION_MAJOR, Some(0)).unwrap()}
  }
  #[inline]
  pub fn schema_version_minor(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(VoceDocument::VT_SCHEMA_VERSION_MINOR, Some(1)).unwrap()}
  }
  #[inline]
  pub fn root(&self) -> ViewRoot<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ViewRoot>>(VoceDocument::VT_ROOT, None).unwrap()}
  }
  /// Application-level route map (for multi-route apps).
  #[inline]
  pub fn routes(&self) -> Option<RouteMap<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<RouteMap>>(VoceDocument::VT_ROUTES, None)}
  }
  /// Theming.
  #[inline]
  pub fn theme(&self) -> Option<ThemeNode<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ThemeNode>>(VoceDocument::VT_THEME, None)}
  }
  #[inline]
  pub fn alternate_themes(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ThemeNode<'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<ThemeNode>>>>(VoceDocument::VT_ALTERNATE_THEMES, None)}
  }
  /// Auth configuration.
  #[inline]
  pub fn auth(&self) -> Option<AuthContextNode<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<AuthContextNode>>(VoceDocument::VT_AUTH, None)}
  }
  /// Internationalization configuration.
  #[inline]
  pub fn i18n(&self) -> Option<I18nConfig<'a>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<I18nConfig>>(VoceDocument::VT_I18N, None)}
  }
}

impl flatbuffers::Verifiable for VoceDocument<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<i32>("schema_version_major", Self::VT_SCHEMA_VERSION_MAJOR, false)?
     .visit_field::<i32>("schema_version_minor", Self::VT_SCHEMA_VERSION_MINOR, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ViewRoot>>("root", Self::VT_ROOT, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<RouteMap>>("routes", Self::VT_ROUTES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<ThemeNode>>("theme", Self::VT_THEME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<ThemeNode>>>>("alternate_themes", Self::VT_ALTERNATE_THEMES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<AuthContextNode>>("auth", Self::VT_AUTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<I18nConfig>>("i18n", Self::VT_I18N, false)?
     .finish();
    Ok(())
  }
}
pub struct VoceDocumentArgs<'a> {
    pub schema_version_major: i32,
    pub schema_version_minor: i32,
    pub root: Option<flatbuffers::WIPOffset<ViewRoot<'a>>>,
    pub routes: Option<flatbuffers::WIPOffset<RouteMap<'a>>>,
    pub theme: Option<flatbuffers::WIPOffset<ThemeNode<'a>>>,
    pub alternate_themes: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<ThemeNode<'a>>>>>,
    pub auth: Option<flatbuffers::WIPOffset<AuthContextNode<'a>>>,
    pub i18n: Option<flatbuffers::WIPOffset<I18nConfig<'a>>>,
}
impl<'a> Default for VoceDocumentArgs<'a> {
  #[inline]
  fn default() -> Self {
    VoceDocumentArgs {
      schema_version_major: 0,
      schema_version_minor: 1,
      root: None, // required field
      routes: None,
      theme: None,
      alternate_themes: None,
      auth: None,
      i18n: None,
    }
  }
}

pub struct VoceDocumentBuilder<'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> VoceDocumentBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_schema_version_major(&mut self, schema_version_major: i32) {
    self.fbb_.push_slot::<i32>(VoceDocument::VT_SCHEMA_VERSION_MAJOR, schema_version_major, 0);
  }
  #[inline]
  pub fn add_schema_version_minor(&mut self, schema_version_minor: i32) {
    self.fbb_.push_slot::<i32>(VoceDocument::VT_SCHEMA_VERSION_MINOR, schema_version_minor, 1);
  }
  #[inline]
  pub fn add_root(&mut self, root: flatbuffers::WIPOffset<ViewRoot<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ViewRoot>>(VoceDocument::VT_ROOT, root);
  }
  #[inline]
  pub fn add_routes(&mut self, routes: flatbuffers::WIPOffset<RouteMap<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<RouteMap>>(VoceDocument::VT_ROUTES, routes);
  }
  #[inline]
  pub fn add_theme(&mut self, theme: flatbuffers::WIPOffset<ThemeNode<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ThemeNode>>(VoceDocument::VT_THEME, theme);
  }
  #[inline]
  pub fn add_alternate_themes(&mut self, alternate_themes: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<ThemeNode<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(VoceDocument::VT_ALTERNATE_THEMES, alternate_themes);
  }
  #[inline]
  pub fn add_auth(&mut self, auth: flatbuffers::WIPOffset<AuthContextNode<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<AuthContextNode>>(VoceDocument::VT_AUTH, auth);
  }
  #[inline]
  pub fn add_i18n(&mut self, i18n: flatbuffers::WIPOffset<I18nConfig<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<I18nConfig>>(VoceDocument::VT_I18N, i18n);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> VoceDocumentBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    VoceDocumentBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<VoceDocument<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, VoceDocument::VT_ROOT,"root");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for VoceDocument<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("VoceDocument");
      ds.field("schema_version_major", &self.schema_version_major());
      ds.field("schema_version_minor", &self.schema_version_minor());
      ds.field("root", &self.root());
      ds.field("routes", &self.routes());
      ds.field("theme", &self.theme());
      ds.field("alternate_themes", &self.alternate_themes());
      ds.field("auth", &self.auth());
      ds.field("i18n", &self.i18n());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `VoceDocument`
/// 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_voce_document_unchecked`.
pub fn root_as_voce_document(buf: &[u8]) -> Result<VoceDocument, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<VoceDocument>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `VoceDocument` 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_voce_document_unchecked`.
pub fn size_prefixed_root_as_voce_document(buf: &[u8]) -> Result<VoceDocument, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<VoceDocument>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `VoceDocument` 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_voce_document_unchecked`.
pub fn root_as_voce_document_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<VoceDocument<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<VoceDocument<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `VoceDocument` 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_voce_document_unchecked`.
pub fn size_prefixed_root_as_voce_document_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<VoceDocument<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<VoceDocument<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a VoceDocument and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `VoceDocument`.
pub unsafe fn root_as_voce_document_unchecked(buf: &[u8]) -> VoceDocument {
  flatbuffers::root_unchecked::<VoceDocument>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed VoceDocument and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `VoceDocument`.
pub unsafe fn size_prefixed_root_as_voce_document_unchecked(buf: &[u8]) -> VoceDocument {
  flatbuffers::size_prefixed_root_unchecked::<VoceDocument>(buf)
}
pub const VOCE_DOCUMENT_IDENTIFIER: &str = "VOCE";

#[inline]
pub fn voce_document_buffer_has_identifier(buf: &[u8]) -> bool {
  flatbuffers::buffer_has_identifier(buf, VOCE_DOCUMENT_IDENTIFIER, false)
}

#[inline]
pub fn voce_document_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
  flatbuffers::buffer_has_identifier(buf, VOCE_DOCUMENT_IDENTIFIER, true)
}

#[inline]
pub fn finish_voce_document_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
    root: flatbuffers::WIPOffset<VoceDocument<'a>>) {
  fbb.finish(root, Some(VOCE_DOCUMENT_IDENTIFIER));
}

#[inline]
pub fn finish_size_prefixed_voce_document_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<VoceDocument<'a>>) {
  fbb.finish_size_prefixed(root, Some(VOCE_DOCUMENT_IDENTIFIER));
}
}  // pub mod voce