// 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};

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

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

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

impl<'a> Property {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    property: i32,
    value: i32,
  ) -> Self {
    let mut s = Self([0; 8]);
    s.set_property(property);
    s.set_value(value);
    s
  }

  pub fn property(&self) -> i32 {
    let mut mem = core::mem::MaybeUninit::<<i32 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::<<i32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_property(&mut self, x: i32) {
    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::<<i32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn value(&self) -> i32 {
    let mut mem = core::mem::MaybeUninit::<<i32 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::<<i32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_value(&mut self, x: i32) {
    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::<<i32 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> RefineCost {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    item_id: i32,
    number: i32,
  ) -> Self {
    let mut s = Self([0; 8]);
    s.set_item_id(item_id);
    s.set_number(number);
    s
  }

  pub fn item_id(&self) -> i32 {
    let mut mem = core::mem::MaybeUninit::<<i32 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::<<i32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_item_id(&mut self, x: i32) {
    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::<<i32 as EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn number(&self) -> i32 {
    let mut mem = core::mem::MaybeUninit::<<i32 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::<<i32 as EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_number(&mut self, x: i32) {
    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::<<i32 as EndianScalar>::Scalar>(),
      );
    }
  }

}

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

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

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

impl<'a> AvatarBaseTemplate<'a> {
  pub const VT_ID: flatbuffers::VOffsetT = 4;
  pub const VT_CODE_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_NAME: flatbuffers::VOffsetT = 8;
  pub const VT_FULL_NAME: flatbuffers::VOffsetT = 10;
  pub const VT_AUDIO_EVENT_REPLACE_PARAM: flatbuffers::VOffsetT = 12;
  pub const VT_AUDIO_BANK: flatbuffers::VOffsetT = 14;
  pub const VT_HIT_TYPES: flatbuffers::VOffsetT = 16;
  pub const VT_ELEMENT_TYPES: flatbuffers::VOffsetT = 18;
  pub const VT_UNK_1: flatbuffers::VOffsetT = 20;
  pub const VT_GENDER: flatbuffers::VOffsetT = 22;
  pub const VT_CAMP: flatbuffers::VOffsetT = 24;
  pub const VT_UNK_2: flatbuffers::VOffsetT = 26;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AvatarBaseTemplate { _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 AvatarBaseTemplateArgs<'args>
  ) -> flatbuffers::WIPOffset<AvatarBaseTemplate<'bldr>> {
    let mut builder = AvatarBaseTemplateBuilder::new(_fbb);
    if let Some(x) = args.unk_2 { builder.add_unk_2(x); }
    builder.add_camp(args.camp);
    builder.add_gender(args.gender);
    builder.add_unk_1(args.unk_1);
    if let Some(x) = args.element_types { builder.add_element_types(x); }
    if let Some(x) = args.hit_types { builder.add_hit_types(x); }
    if let Some(x) = args.audio_bank { builder.add_audio_bank(x); }
    if let Some(x) = args.audio_event_replace_param { builder.add_audio_event_replace_param(x); }
    if let Some(x) = args.full_name { builder.add_full_name(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    if let Some(x) = args.code_name { builder.add_code_name(x); }
    builder.add_id(args.id);
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(AvatarBaseTemplate::VT_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn code_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>>(AvatarBaseTemplate::VT_CODE_NAME, None)}
  }
  #[inline]
  pub fn name(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(AvatarBaseTemplate::VT_NAME, None)}
  }
  #[inline]
  pub fn full_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>>(AvatarBaseTemplate::VT_FULL_NAME, None)}
  }
  #[inline]
  pub fn audio_event_replace_param(&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>>(AvatarBaseTemplate::VT_AUDIO_EVENT_REPLACE_PARAM, None)}
  }
  #[inline]
  pub fn audio_bank(&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>>(AvatarBaseTemplate::VT_AUDIO_BANK, None)}
  }
  #[inline]
  pub fn hit_types(&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>>>(AvatarBaseTemplate::VT_HIT_TYPES, None)}
  }
  #[inline]
  pub fn element_types(&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>>>(AvatarBaseTemplate::VT_ELEMENT_TYPES, None)}
  }
  #[inline]
  pub fn unk_1(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(AvatarBaseTemplate::VT_UNK_1, Some(0)).unwrap()}
  }
  #[inline]
  pub fn gender(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(AvatarBaseTemplate::VT_GENDER, Some(0)).unwrap()}
  }
  #[inline]
  pub fn camp(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(AvatarBaseTemplate::VT_CAMP, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_2(&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>>>>(AvatarBaseTemplate::VT_UNK_2, None)}
  }
}

impl flatbuffers::Verifiable for AvatarBaseTemplate<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<i32>("id", Self::VT_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("code_name", Self::VT_CODE_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("full_name", Self::VT_FULL_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("audio_event_replace_param", Self::VT_AUDIO_EVENT_REPLACE_PARAM, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("audio_bank", Self::VT_AUDIO_BANK, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>("hit_types", Self::VT_HIT_TYPES, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>("element_types", Self::VT_ELEMENT_TYPES, false)?
     .visit_field::<i32>("unk_1", Self::VT_UNK_1, false)?
     .visit_field::<i32>("gender", Self::VT_GENDER, false)?
     .visit_field::<i32>("camp", Self::VT_CAMP, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("unk_2", Self::VT_UNK_2, false)?
     .finish();
    Ok(())
  }
}
pub struct AvatarBaseTemplateArgs<'a> {
    pub id: i32,
    pub code_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub full_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub audio_event_replace_param: Option<flatbuffers::WIPOffset<&'a str>>,
    pub audio_bank: Option<flatbuffers::WIPOffset<&'a str>>,
    pub hit_types: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i32>>>,
    pub element_types: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i32>>>,
    pub unk_1: i32,
    pub gender: i32,
    pub camp: i32,
    pub unk_2: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
}
impl<'a> Default for AvatarBaseTemplateArgs<'a> {
  #[inline]
  fn default() -> Self {
    AvatarBaseTemplateArgs {
      id: 0,
      code_name: None,
      name: None,
      full_name: None,
      audio_event_replace_param: None,
      audio_bank: None,
      hit_types: None,
      element_types: None,
      unk_1: 0,
      gender: 0,
      camp: 0,
      unk_2: None,
    }
  }
}

pub struct AvatarBaseTemplateBuilder<'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> AvatarBaseTemplateBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: i32) {
    self.fbb_.push_slot::<i32>(AvatarBaseTemplate::VT_ID, id, 0);
  }
  #[inline]
  pub fn add_code_name(&mut self, code_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_CODE_NAME, code_name);
  }
  #[inline]
  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_NAME, name);
  }
  #[inline]
  pub fn add_full_name(&mut self, full_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_FULL_NAME, full_name);
  }
  #[inline]
  pub fn add_audio_event_replace_param(&mut self, audio_event_replace_param: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_AUDIO_EVENT_REPLACE_PARAM, audio_event_replace_param);
  }
  #[inline]
  pub fn add_audio_bank(&mut self, audio_bank: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_AUDIO_BANK, audio_bank);
  }
  #[inline]
  pub fn add_hit_types(&mut self, hit_types: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_HIT_TYPES, hit_types);
  }
  #[inline]
  pub fn add_element_types(&mut self, element_types: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_ELEMENT_TYPES, element_types);
  }
  #[inline]
  pub fn add_unk_1(&mut self, unk_1: i32) {
    self.fbb_.push_slot::<i32>(AvatarBaseTemplate::VT_UNK_1, unk_1, 0);
  }
  #[inline]
  pub fn add_gender(&mut self, gender: i32) {
    self.fbb_.push_slot::<i32>(AvatarBaseTemplate::VT_GENDER, gender, 0);
  }
  #[inline]
  pub fn add_camp(&mut self, camp: i32) {
    self.fbb_.push_slot::<i32>(AvatarBaseTemplate::VT_CAMP, camp, 0);
  }
  #[inline]
  pub fn add_unk_2(&mut self, unk_2: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AvatarBaseTemplate::VT_UNK_2, unk_2);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AvatarBaseTemplateBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AvatarBaseTemplateBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AvatarBaseTemplate<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for AvatarBaseTemplate<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("AvatarBaseTemplate");
      ds.field("id", &self.id());
      ds.field("code_name", &self.code_name());
      ds.field("name", &self.name());
      ds.field("full_name", &self.full_name());
      ds.field("audio_event_replace_param", &self.audio_event_replace_param());
      ds.field("audio_bank", &self.audio_bank());
      ds.field("hit_types", &self.hit_types());
      ds.field("element_types", &self.element_types());
      ds.field("unk_1", &self.unk_1());
      ds.field("gender", &self.gender());
      ds.field("camp", &self.camp());
      ds.field("unk_2", &self.unk_2());
      ds.finish()
  }
}
pub enum WeaponTemplateOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> WeaponTemplate<'a> {
  pub const VT_ITEM_ID: flatbuffers::VOffsetT = 4;
  pub const VT_WEAPON_NAME: flatbuffers::VOffsetT = 6;
  pub const VT_UNK_MISSING_FIELD: flatbuffers::VOffsetT = 8;
  pub const VT_BASE_PROPERTY: flatbuffers::VOffsetT = 10;
  pub const VT_RAND_PROPERTY: flatbuffers::VOffsetT = 12;
  pub const VT_STAR_LIMIT: flatbuffers::VOffsetT = 14;
  pub const VT_EXP_RECYCLE: flatbuffers::VOffsetT = 16;
  pub const VT_WEAPON_SCRIPT_CONFIG: flatbuffers::VOffsetT = 18;
  pub const VT_WEAPON_UI_MODEL: flatbuffers::VOffsetT = 20;
  pub const VT_UNK_1: flatbuffers::VOffsetT = 22;
  pub const VT_UNK_MISSING_FIELD_2: flatbuffers::VOffsetT = 24;
  pub const VT_UNK_WEAPON_PATH: flatbuffers::VOffsetT = 26;
  pub const VT_UNK_MISSING_FIELD_3: flatbuffers::VOffsetT = 28;
  pub const VT_REFINE_INITIAL: flatbuffers::VOffsetT = 30;
  pub const VT_REFINE_LIMIT: flatbuffers::VOffsetT = 32;
  pub const VT_UNK_MISSING_FIELD_4: flatbuffers::VOffsetT = 34;
  pub const VT_UNK_MISSING_FIELD_5: flatbuffers::VOffsetT = 36;
  pub const VT_UNK_STRING_WITH_VALUES: flatbuffers::VOffsetT = 38;
  pub const VT_UNK_MISSING_FIELD_6: flatbuffers::VOffsetT = 40;
  pub const VT_UNK_2: flatbuffers::VOffsetT = 42;
  pub const VT_WEAPON_DESC: flatbuffers::VOffsetT = 44;
  pub const VT_WEAPON_RELEASE_TAG: flatbuffers::VOffsetT = 46;
  pub const VT_UNK_EMPTY_STRING: flatbuffers::VOffsetT = 48;
  pub const VT_AVATAR_ID: flatbuffers::VOffsetT = 50;
  pub const VT_WEAPON_COMMENT: flatbuffers::VOffsetT = 52;
  pub const VT_REFINE_COSTS: flatbuffers::VOffsetT = 54;
  pub const VT_UNK_3: flatbuffers::VOffsetT = 56;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    WeaponTemplate { _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 WeaponTemplateArgs<'args>
  ) -> flatbuffers::WIPOffset<WeaponTemplate<'bldr>> {
    let mut builder = WeaponTemplateBuilder::new(_fbb);
    builder.add_unk_3(args.unk_3);
    if let Some(x) = args.refine_costs { builder.add_refine_costs(x); }
    if let Some(x) = args.weapon_comment { builder.add_weapon_comment(x); }
    builder.add_avatar_id(args.avatar_id);
    if let Some(x) = args.unk_empty_string { builder.add_unk_empty_string(x); }
    if let Some(x) = args.weapon_release_tag { builder.add_weapon_release_tag(x); }
    if let Some(x) = args.weapon_desc { builder.add_weapon_desc(x); }
    builder.add_unk_2(args.unk_2);
    builder.add_unk_missing_field_6(args.unk_missing_field_6);
    if let Some(x) = args.unk_string_with_values { builder.add_unk_string_with_values(x); }
    builder.add_unk_missing_field_5(args.unk_missing_field_5);
    builder.add_unk_missing_field_4(args.unk_missing_field_4);
    builder.add_refine_limit(args.refine_limit);
    builder.add_refine_initial(args.refine_initial);
    builder.add_unk_missing_field_3(args.unk_missing_field_3);
    if let Some(x) = args.unk_weapon_path { builder.add_unk_weapon_path(x); }
    builder.add_unk_missing_field_2(args.unk_missing_field_2);
    builder.add_unk_1(args.unk_1);
    if let Some(x) = args.weapon_ui_model { builder.add_weapon_ui_model(x); }
    if let Some(x) = args.weapon_script_config { builder.add_weapon_script_config(x); }
    builder.add_exp_recycle(args.exp_recycle);
    builder.add_star_limit(args.star_limit);
    if let Some(x) = args.rand_property { builder.add_rand_property(x); }
    if let Some(x) = args.base_property { builder.add_base_property(x); }
    builder.add_unk_missing_field(args.unk_missing_field);
    if let Some(x) = args.weapon_name { builder.add_weapon_name(x); }
    builder.add_item_id(args.item_id);
    builder.finish()
  }


  #[inline]
  pub fn item_id(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_ITEM_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn weapon_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>>(WeaponTemplate::VT_WEAPON_NAME, None)}
  }
  #[inline]
  pub fn unk_missing_field(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD, Some(0)).unwrap()}
  }
  #[inline]
  pub fn base_property(&self) -> Option<&'a Property> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Property>(WeaponTemplate::VT_BASE_PROPERTY, None)}
  }
  #[inline]
  pub fn rand_property(&self) -> Option<&'a Property> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Property>(WeaponTemplate::VT_RAND_PROPERTY, None)}
  }
  #[inline]
  pub fn star_limit(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_STAR_LIMIT, Some(0)).unwrap()}
  }
  #[inline]
  pub fn exp_recycle(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_EXP_RECYCLE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn weapon_script_config(&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>>(WeaponTemplate::VT_WEAPON_SCRIPT_CONFIG, None)}
  }
  #[inline]
  pub fn weapon_ui_model(&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>>(WeaponTemplate::VT_WEAPON_UI_MODEL, None)}
  }
  #[inline]
  pub fn unk_1(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_1, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_missing_field_2(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_2, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_weapon_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>>(WeaponTemplate::VT_UNK_WEAPON_PATH, None)}
  }
  #[inline]
  pub fn unk_missing_field_3(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_3, Some(0)).unwrap()}
  }
  #[inline]
  pub fn refine_initial(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_REFINE_INITIAL, Some(0)).unwrap()}
  }
  #[inline]
  pub fn refine_limit(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_REFINE_LIMIT, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_missing_field_4(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_4, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_missing_field_5(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_5, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_string_with_values(&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>>(WeaponTemplate::VT_UNK_STRING_WITH_VALUES, None)}
  }
  #[inline]
  pub fn unk_missing_field_6(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_6, Some(0)).unwrap()}
  }
  #[inline]
  pub fn unk_2(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_2, Some(0)).unwrap()}
  }
  #[inline]
  pub fn weapon_desc(&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>>(WeaponTemplate::VT_WEAPON_DESC, None)}
  }
  #[inline]
  pub fn weapon_release_tag(&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>>(WeaponTemplate::VT_WEAPON_RELEASE_TAG, None)}
  }
  #[inline]
  pub fn unk_empty_string(&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>>(WeaponTemplate::VT_UNK_EMPTY_STRING, None)}
  }
  #[inline]
  pub fn avatar_id(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_AVATAR_ID, Some(0)).unwrap()}
  }
  #[inline]
  pub fn weapon_comment(&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>>(WeaponTemplate::VT_WEAPON_COMMENT, None)}
  }
  #[inline]
  pub fn refine_costs(&self) -> Option<flatbuffers::Vector<'a, RefineCost>> {
    // 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, RefineCost>>>(WeaponTemplate::VT_REFINE_COSTS, None)}
  }
  #[inline]
  pub fn unk_3(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(WeaponTemplate::VT_UNK_3, Some(0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for WeaponTemplate<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<i32>("item_id", Self::VT_ITEM_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_name", Self::VT_WEAPON_NAME, false)?
     .visit_field::<i32>("unk_missing_field", Self::VT_UNK_MISSING_FIELD, false)?
     .visit_field::<Property>("base_property", Self::VT_BASE_PROPERTY, false)?
     .visit_field::<Property>("rand_property", Self::VT_RAND_PROPERTY, false)?
     .visit_field::<i32>("star_limit", Self::VT_STAR_LIMIT, false)?
     .visit_field::<i32>("exp_recycle", Self::VT_EXP_RECYCLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_script_config", Self::VT_WEAPON_SCRIPT_CONFIG, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_ui_model", Self::VT_WEAPON_UI_MODEL, false)?
     .visit_field::<i32>("unk_1", Self::VT_UNK_1, false)?
     .visit_field::<i32>("unk_missing_field_2", Self::VT_UNK_MISSING_FIELD_2, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("unk_weapon_path", Self::VT_UNK_WEAPON_PATH, false)?
     .visit_field::<i32>("unk_missing_field_3", Self::VT_UNK_MISSING_FIELD_3, false)?
     .visit_field::<i32>("refine_initial", Self::VT_REFINE_INITIAL, false)?
     .visit_field::<i32>("refine_limit", Self::VT_REFINE_LIMIT, false)?
     .visit_field::<i32>("unk_missing_field_4", Self::VT_UNK_MISSING_FIELD_4, false)?
     .visit_field::<i32>("unk_missing_field_5", Self::VT_UNK_MISSING_FIELD_5, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("unk_string_with_values", Self::VT_UNK_STRING_WITH_VALUES, false)?
     .visit_field::<i32>("unk_missing_field_6", Self::VT_UNK_MISSING_FIELD_6, false)?
     .visit_field::<i32>("unk_2", Self::VT_UNK_2, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_desc", Self::VT_WEAPON_DESC, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_release_tag", Self::VT_WEAPON_RELEASE_TAG, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("unk_empty_string", Self::VT_UNK_EMPTY_STRING, false)?
     .visit_field::<i32>("avatar_id", Self::VT_AVATAR_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("weapon_comment", Self::VT_WEAPON_COMMENT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, RefineCost>>>("refine_costs", Self::VT_REFINE_COSTS, false)?
     .visit_field::<i32>("unk_3", Self::VT_UNK_3, false)?
     .finish();
    Ok(())
  }
}
pub struct WeaponTemplateArgs<'a> {
    pub item_id: i32,
    pub weapon_name: Option<flatbuffers::WIPOffset<&'a str>>,
    pub unk_missing_field: i32,
    pub base_property: Option<&'a Property>,
    pub rand_property: Option<&'a Property>,
    pub star_limit: i32,
    pub exp_recycle: i32,
    pub weapon_script_config: Option<flatbuffers::WIPOffset<&'a str>>,
    pub weapon_ui_model: Option<flatbuffers::WIPOffset<&'a str>>,
    pub unk_1: i32,
    pub unk_missing_field_2: i32,
    pub unk_weapon_path: Option<flatbuffers::WIPOffset<&'a str>>,
    pub unk_missing_field_3: i32,
    pub refine_initial: i32,
    pub refine_limit: i32,
    pub unk_missing_field_4: i32,
    pub unk_missing_field_5: i32,
    pub unk_string_with_values: Option<flatbuffers::WIPOffset<&'a str>>,
    pub unk_missing_field_6: i32,
    pub unk_2: i32,
    pub weapon_desc: Option<flatbuffers::WIPOffset<&'a str>>,
    pub weapon_release_tag: Option<flatbuffers::WIPOffset<&'a str>>,
    pub unk_empty_string: Option<flatbuffers::WIPOffset<&'a str>>,
    pub avatar_id: i32,
    pub weapon_comment: Option<flatbuffers::WIPOffset<&'a str>>,
    pub refine_costs: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, RefineCost>>>,
    pub unk_3: i32,
}
impl<'a> Default for WeaponTemplateArgs<'a> {
  #[inline]
  fn default() -> Self {
    WeaponTemplateArgs {
      item_id: 0,
      weapon_name: None,
      unk_missing_field: 0,
      base_property: None,
      rand_property: None,
      star_limit: 0,
      exp_recycle: 0,
      weapon_script_config: None,
      weapon_ui_model: None,
      unk_1: 0,
      unk_missing_field_2: 0,
      unk_weapon_path: None,
      unk_missing_field_3: 0,
      refine_initial: 0,
      refine_limit: 0,
      unk_missing_field_4: 0,
      unk_missing_field_5: 0,
      unk_string_with_values: None,
      unk_missing_field_6: 0,
      unk_2: 0,
      weapon_desc: None,
      weapon_release_tag: None,
      unk_empty_string: None,
      avatar_id: 0,
      weapon_comment: None,
      refine_costs: None,
      unk_3: 0,
    }
  }
}

pub struct WeaponTemplateBuilder<'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> WeaponTemplateBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_item_id(&mut self, item_id: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_ITEM_ID, item_id, 0);
  }
  #[inline]
  pub fn add_weapon_name(&mut self, weapon_name: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_NAME, weapon_name);
  }
  #[inline]
  pub fn add_unk_missing_field(&mut self, unk_missing_field: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD, unk_missing_field, 0);
  }
  #[inline]
  pub fn add_base_property(&mut self, base_property: &Property) {
    self.fbb_.push_slot_always::<&Property>(WeaponTemplate::VT_BASE_PROPERTY, base_property);
  }
  #[inline]
  pub fn add_rand_property(&mut self, rand_property: &Property) {
    self.fbb_.push_slot_always::<&Property>(WeaponTemplate::VT_RAND_PROPERTY, rand_property);
  }
  #[inline]
  pub fn add_star_limit(&mut self, star_limit: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_STAR_LIMIT, star_limit, 0);
  }
  #[inline]
  pub fn add_exp_recycle(&mut self, exp_recycle: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_EXP_RECYCLE, exp_recycle, 0);
  }
  #[inline]
  pub fn add_weapon_script_config(&mut self, weapon_script_config: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_SCRIPT_CONFIG, weapon_script_config);
  }
  #[inline]
  pub fn add_weapon_ui_model(&mut self, weapon_ui_model: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_UI_MODEL, weapon_ui_model);
  }
  #[inline]
  pub fn add_unk_1(&mut self, unk_1: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_1, unk_1, 0);
  }
  #[inline]
  pub fn add_unk_missing_field_2(&mut self, unk_missing_field_2: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_2, unk_missing_field_2, 0);
  }
  #[inline]
  pub fn add_unk_weapon_path(&mut self, unk_weapon_path: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_UNK_WEAPON_PATH, unk_weapon_path);
  }
  #[inline]
  pub fn add_unk_missing_field_3(&mut self, unk_missing_field_3: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_3, unk_missing_field_3, 0);
  }
  #[inline]
  pub fn add_refine_initial(&mut self, refine_initial: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_REFINE_INITIAL, refine_initial, 0);
  }
  #[inline]
  pub fn add_refine_limit(&mut self, refine_limit: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_REFINE_LIMIT, refine_limit, 0);
  }
  #[inline]
  pub fn add_unk_missing_field_4(&mut self, unk_missing_field_4: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_4, unk_missing_field_4, 0);
  }
  #[inline]
  pub fn add_unk_missing_field_5(&mut self, unk_missing_field_5: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_5, unk_missing_field_5, 0);
  }
  #[inline]
  pub fn add_unk_string_with_values(&mut self, unk_string_with_values: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_UNK_STRING_WITH_VALUES, unk_string_with_values);
  }
  #[inline]
  pub fn add_unk_missing_field_6(&mut self, unk_missing_field_6: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_MISSING_FIELD_6, unk_missing_field_6, 0);
  }
  #[inline]
  pub fn add_unk_2(&mut self, unk_2: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_2, unk_2, 0);
  }
  #[inline]
  pub fn add_weapon_desc(&mut self, weapon_desc: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_DESC, weapon_desc);
  }
  #[inline]
  pub fn add_weapon_release_tag(&mut self, weapon_release_tag: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_RELEASE_TAG, weapon_release_tag);
  }
  #[inline]
  pub fn add_unk_empty_string(&mut self, unk_empty_string: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_UNK_EMPTY_STRING, unk_empty_string);
  }
  #[inline]
  pub fn add_avatar_id(&mut self, avatar_id: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_AVATAR_ID, avatar_id, 0);
  }
  #[inline]
  pub fn add_weapon_comment(&mut self, weapon_comment: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_WEAPON_COMMENT, weapon_comment);
  }
  #[inline]
  pub fn add_refine_costs(&mut self, refine_costs: flatbuffers::WIPOffset<flatbuffers::Vector<'b , RefineCost>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(WeaponTemplate::VT_REFINE_COSTS, refine_costs);
  }
  #[inline]
  pub fn add_unk_3(&mut self, unk_3: i32) {
    self.fbb_.push_slot::<i32>(WeaponTemplate::VT_UNK_3, unk_3, 0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponTemplateBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    WeaponTemplateBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<WeaponTemplate<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for WeaponTemplate<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("WeaponTemplate");
      ds.field("item_id", &self.item_id());
      ds.field("weapon_name", &self.weapon_name());
      ds.field("unk_missing_field", &self.unk_missing_field());
      ds.field("base_property", &self.base_property());
      ds.field("rand_property", &self.rand_property());
      ds.field("star_limit", &self.star_limit());
      ds.field("exp_recycle", &self.exp_recycle());
      ds.field("weapon_script_config", &self.weapon_script_config());
      ds.field("weapon_ui_model", &self.weapon_ui_model());
      ds.field("unk_1", &self.unk_1());
      ds.field("unk_missing_field_2", &self.unk_missing_field_2());
      ds.field("unk_weapon_path", &self.unk_weapon_path());
      ds.field("unk_missing_field_3", &self.unk_missing_field_3());
      ds.field("refine_initial", &self.refine_initial());
      ds.field("refine_limit", &self.refine_limit());
      ds.field("unk_missing_field_4", &self.unk_missing_field_4());
      ds.field("unk_missing_field_5", &self.unk_missing_field_5());
      ds.field("unk_string_with_values", &self.unk_string_with_values());
      ds.field("unk_missing_field_6", &self.unk_missing_field_6());
      ds.field("unk_2", &self.unk_2());
      ds.field("weapon_desc", &self.weapon_desc());
      ds.field("weapon_release_tag", &self.weapon_release_tag());
      ds.field("unk_empty_string", &self.unk_empty_string());
      ds.field("avatar_id", &self.avatar_id());
      ds.field("weapon_comment", &self.weapon_comment());
      ds.field("refine_costs", &self.refine_costs());
      ds.field("unk_3", &self.unk_3());
      ds.finish()
  }
}
pub enum AvatarBaseTemplateTbOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> AvatarBaseTemplateTb<'a> {
  pub const VT_DATA: flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn data(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AvatarBaseTemplate<'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<AvatarBaseTemplate>>>>(AvatarBaseTemplateTb::VT_DATA, None)}
  }
}

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

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

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

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

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

impl<'a> WeaponTemplateTb<'a> {
  pub const VT_DATA: flatbuffers::VOffsetT = 4;

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


  #[inline]
  pub fn data(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<WeaponTemplate<'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<WeaponTemplate>>>>(WeaponTemplateTb::VT_DATA, None)}
  }
}

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

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

impl core::fmt::Debug for WeaponTemplateTb<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("WeaponTemplateTb");
      ds.field("data", &self.data());
      ds.finish()
  }
}
