#[inline]
  pub fn type_type(&self) -> KeywordsInUnion {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<KeywordsInUnion>(Table2::VT_TYPE_TYPE, Some(KeywordsInUnion::NONE)).unwrap()}
  }
  #[inline]
  pub fn type_(&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>>>(Table2::VT_TYPE_, None)}
  }

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

table Null {                                                                    
}                                                                               
                                                                                
union DType {                                                                   
  Null,                                                                         
}                                                                               
                                                                                
table Field {                                                                   
  /// This is the type of the decoded value if the field is dictionary encoded. 
  static: DType;                                                                
  saman: DType;                                                                 
} 

  DType static_type() const {                                                   
    return static_cast<DType>(GetField<uint8_t>(VT_STATIC_TYPE, 0));            
  }                                                                             
  /// This is the type of the decoded value if the field is dictionary encoded. 
  const void *static_() const {                                                 
    return GetPointer<const void *>(VT_STATIC_);                                
  } 
  template<typename T> const T *static__as() const;                             
  const Null *static__as_Null() const {                                         
    // <= static__type is WRONG !!!
    return static__type() == DType_Null ? static_cast<const Null *>(static_()) : nullptr;
  }