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

// @generated

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

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

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

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

    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_BASE_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_BASE_TYPE: i8 = 19;
    #[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_BASE_TYPE: [BaseType; 20] = [
        BaseType::None,
        BaseType::UType,
        BaseType::Bool,
        BaseType::Byte,
        BaseType::UByte,
        BaseType::Short,
        BaseType::UShort,
        BaseType::Int,
        BaseType::UInt,
        BaseType::Long,
        BaseType::ULong,
        BaseType::Float,
        BaseType::Double,
        BaseType::String,
        BaseType::Vector,
        BaseType::Obj,
        BaseType::Union,
        BaseType::Array,
        BaseType::Vector64,
        BaseType::MaxBaseType,
    ];

    #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
    #[repr(transparent)]
    pub struct BaseType(pub i8);
    #[allow(non_upper_case_globals)]
    impl BaseType {
        pub const None: Self = Self(0);
        pub const UType: Self = Self(1);
        pub const Bool: Self = Self(2);
        pub const Byte: Self = Self(3);
        pub const UByte: Self = Self(4);
        pub const Short: Self = Self(5);
        pub const UShort: Self = Self(6);
        pub const Int: Self = Self(7);
        pub const UInt: Self = Self(8);
        pub const Long: Self = Self(9);
        pub const ULong: Self = Self(10);
        pub const Float: Self = Self(11);
        pub const Double: Self = Self(12);
        pub const String: Self = Self(13);
        pub const Vector: Self = Self(14);
        pub const Obj: Self = Self(15);
        pub const Union: Self = Self(16);
        pub const Array: Self = Self(17);
        pub const Vector64: Self = Self(18);
        pub const MaxBaseType: Self = Self(19);

        pub const ENUM_MIN: i8 = 0;
        pub const ENUM_MAX: i8 = 19;
        pub const ENUM_VALUES: &'static [Self] = &[
            Self::None,
            Self::UType,
            Self::Bool,
            Self::Byte,
            Self::UByte,
            Self::Short,
            Self::UShort,
            Self::Int,
            Self::UInt,
            Self::Long,
            Self::ULong,
            Self::Float,
            Self::Double,
            Self::String,
            Self::Vector,
            Self::Obj,
            Self::Union,
            Self::Array,
            Self::Vector64,
            Self::MaxBaseType,
        ];
        /// Returns the variant's name or "" if unknown.
        pub fn variant_name(self) -> Option<&'static str> {
            match self {
                Self::None => Some("None"),
                Self::UType => Some("UType"),
                Self::Bool => Some("Bool"),
                Self::Byte => Some("Byte"),
                Self::UByte => Some("UByte"),
                Self::Short => Some("Short"),
                Self::UShort => Some("UShort"),
                Self::Int => Some("Int"),
                Self::UInt => Some("UInt"),
                Self::Long => Some("Long"),
                Self::ULong => Some("ULong"),
                Self::Float => Some("Float"),
                Self::Double => Some("Double"),
                Self::String => Some("String"),
                Self::Vector => Some("Vector"),
                Self::Obj => Some("Obj"),
                Self::Union => Some("Union"),
                Self::Array => Some("Array"),
                Self::Vector64 => Some("Vector64"),
                Self::MaxBaseType => Some("MaxBaseType"),
                _ => None,
            }
        }
    }
    impl core::fmt::Debug for BaseType {
        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 BaseType {
        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 BaseType {
        type Output = BaseType;
        #[inline]
        unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
            flatbuffers::emplace_scalar::<i8>(dst, self.0);
        }
    }

    impl flatbuffers::EndianScalar for BaseType {
        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 BaseType {
        #[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 BaseType {}
    #[allow(non_upper_case_globals)]
    mod bitflags_advanced_features {
        flatbuffers::bitflags::bitflags! {
          /// New schema language features that are not supported by old code generators.
          #[derive(Default, Debug, Clone, Copy, PartialEq)]
          pub struct AdvancedFeatures: u64 {
            const AdvancedArrayFeatures = 1;
            const AdvancedUnionFeatures = 2;
            const OptionalScalars = 4;
            const DefaultVectorsAndStrings = 8;
          }
        }
    }
    pub use self::bitflags_advanced_features::AdvancedFeatures;

    impl<'a> flatbuffers::Follow<'a> for AdvancedFeatures {
        type Inner = Self;
        #[inline]
        unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
            let b = flatbuffers::read_scalar_at::<u64>(buf, loc);
            Self::from_bits_retain(b)
        }
    }

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

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

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

    impl flatbuffers::SimpleToVerifyInSlice for AdvancedFeatures {}
    pub enum TypeOffset {}
    #[derive(Copy, Clone, PartialEq)]

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

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

    impl<'a> Type<'a> {
        pub const VT_BASE_TYPE: flatbuffers::VOffsetT = 4;
        pub const VT_ELEMENT: flatbuffers::VOffsetT = 6;
        pub const VT_INDEX: flatbuffers::VOffsetT = 8;
        pub const VT_FIXED_LENGTH: flatbuffers::VOffsetT = 10;
        pub const VT_BASE_SIZE: flatbuffers::VOffsetT = 12;
        pub const VT_ELEMENT_SIZE: flatbuffers::VOffsetT = 14;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Type { _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 TypeArgs,
        ) -> flatbuffers::WIPOffset<Type<'bldr>> {
            let mut builder = TypeBuilder::new(_fbb);
            builder.add_element_size(args.element_size);
            builder.add_base_size(args.base_size);
            builder.add_index(args.index);
            builder.add_fixed_length(args.fixed_length);
            builder.add_element(args.element);
            builder.add_base_type(args.base_type);
            builder.finish()
        }

        #[inline]
        pub fn base_type(&self) -> BaseType {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<BaseType>(Type::VT_BASE_TYPE, Some(BaseType::None)).unwrap() }
        }
        #[inline]
        pub fn element(&self) -> BaseType {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<BaseType>(Type::VT_ELEMENT, Some(BaseType::None)).unwrap() }
        }
        #[inline]
        pub fn index(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i32>(Type::VT_INDEX, Some(-1)).unwrap() }
        }
        #[inline]
        pub fn fixed_length(&self) -> u16 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u16>(Type::VT_FIXED_LENGTH, Some(0)).unwrap() }
        }
        /// The size (octets) of the `base_type` field.
        #[inline]
        pub fn base_size(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(Type::VT_BASE_SIZE, Some(4)).unwrap() }
        }
        /// The size (octets) of the `element` field, if present.
        #[inline]
        pub fn element_size(&self) -> u32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u32>(Type::VT_ELEMENT_SIZE, Some(0)).unwrap() }
        }
    }

    impl flatbuffers::Verifiable for Type<'_> {
        #[inline]
        fn run_verifier(
            v: &mut flatbuffers::Verifier,
            pos: usize,
        ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
            use self::flatbuffers::Verifiable;
            v.visit_table(pos)?
                .visit_field::<BaseType>("base_type", Self::VT_BASE_TYPE, false)?
                .visit_field::<BaseType>("element", Self::VT_ELEMENT, false)?
                .visit_field::<i32>("index", Self::VT_INDEX, false)?
                .visit_field::<u16>("fixed_length", Self::VT_FIXED_LENGTH, false)?
                .visit_field::<u32>("base_size", Self::VT_BASE_SIZE, false)?
                .visit_field::<u32>("element_size", Self::VT_ELEMENT_SIZE, false)?
                .finish();
            Ok(())
        }
    }
    pub struct TypeArgs {
        pub base_type: BaseType,
        pub element: BaseType,
        pub index: i32,
        pub fixed_length: u16,
        pub base_size: u32,
        pub element_size: u32,
    }
    impl<'a> Default for TypeArgs {
        #[inline]
        fn default() -> Self {
            TypeArgs {
                base_type: BaseType::None,
                element: BaseType::None,
                index: -1,
                fixed_length: 0,
                base_size: 4,
                element_size: 0,
            }
        }
    }

    pub struct TypeBuilder<'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> TypeBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_base_type(&mut self, base_type: BaseType) {
            self.fbb_.push_slot::<BaseType>(Type::VT_BASE_TYPE, base_type, BaseType::None);
        }
        #[inline]
        pub fn add_element(&mut self, element: BaseType) {
            self.fbb_.push_slot::<BaseType>(Type::VT_ELEMENT, element, BaseType::None);
        }
        #[inline]
        pub fn add_index(&mut self, index: i32) {
            self.fbb_.push_slot::<i32>(Type::VT_INDEX, index, -1);
        }
        #[inline]
        pub fn add_fixed_length(&mut self, fixed_length: u16) {
            self.fbb_.push_slot::<u16>(Type::VT_FIXED_LENGTH, fixed_length, 0);
        }
        #[inline]
        pub fn add_base_size(&mut self, base_size: u32) {
            self.fbb_.push_slot::<u32>(Type::VT_BASE_SIZE, base_size, 4);
        }
        #[inline]
        pub fn add_element_size(&mut self, element_size: u32) {
            self.fbb_.push_slot::<u32>(Type::VT_ELEMENT_SIZE, element_size, 0);
        }
        #[inline]
        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> TypeBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            TypeBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Type<'a>> {
            let o = self.fbb_.end_table(self.start_);
            flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl core::fmt::Debug for Type<'_> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            let mut ds = f.debug_struct("Type");
            ds.field("base_type", &self.base_type());
            ds.field("element", &self.element());
            ds.field("index", &self.index());
            ds.field("fixed_length", &self.fixed_length());
            ds.field("base_size", &self.base_size());
            ds.field("element_size", &self.element_size());
            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 key_compare_less_than(&self, o: &KeyValue) -> bool {
            self.key() < o.key()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.key();
            key.cmp(val)
        }
        #[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>>(KeyValue::VT_VALUE, None) }
        }
    }

    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, false)?
                .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,
            }
        }
    }

    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");
            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 EnumValOffset {}
    #[derive(Copy, Clone, PartialEq)]

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

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

    impl<'a> EnumVal<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_VALUE: flatbuffers::VOffsetT = 6;
        pub const VT_UNION_TYPE: flatbuffers::VOffsetT = 10;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 12;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 14;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            EnumVal { _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 EnumValArgs<'args>,
        ) -> flatbuffers::WIPOffset<EnumVal<'bldr>> {
            let mut builder = EnumValBuilder::new(_fbb);
            builder.add_value(args.value);
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.union_type {
                builder.add_union_type(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>>(EnumVal::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn value(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i64>(EnumVal::VT_VALUE, Some(0)).unwrap() }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &EnumVal) -> bool {
            self.value() < o.value()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: i64) -> ::core::cmp::Ordering {
            let key = self.value();
            key.cmp(&val)
        }
        #[inline]
        pub fn union_type(&self) -> Option<Type<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<flatbuffers::ForwardsUOffset<Type>>(EnumVal::VT_UNION_TYPE, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(EnumVal::VT_DOCUMENTATION, None)
            }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(EnumVal::VT_ATTRIBUTES, None)
            }
        }
    }

    impl flatbuffers::Verifiable for EnumVal<'_> {
        #[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::<i64>("value", Self::VT_VALUE, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<Type>>(
                    "union_type",
                    Self::VT_UNION_TYPE,
                    false,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .finish();
            Ok(())
        }
    }
    pub struct EnumValArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub value: i64,
        pub union_type: Option<flatbuffers::WIPOffset<Type<'a>>>,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
    }
    impl<'a> Default for EnumValArgs<'a> {
        #[inline]
        fn default() -> Self {
            EnumValArgs {
                name: None, // required field
                value: 0,
                union_type: None,
                documentation: None,
                attributes: None,
            }
        }
    }

    pub struct EnumValBuilder<'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> EnumValBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(EnumVal::VT_NAME, name);
        }
        #[inline]
        pub fn add_value(&mut self, value: i64) {
            self.fbb_.push_slot::<i64>(EnumVal::VT_VALUE, value, 0);
        }
        #[inline]
        pub fn add_union_type(&mut self, union_type: flatbuffers::WIPOffset<Type<'b>>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Type>>(
                EnumVal::VT_UNION_TYPE,
                union_type,
            );
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                EnumVal::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(EnumVal::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> EnumValBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            EnumValBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<EnumVal<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, EnumVal::VT_NAME, "name");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

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

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

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

    impl<'a> Enum<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_VALUES: flatbuffers::VOffsetT = 6;
        pub const VT_IS_UNION: flatbuffers::VOffsetT = 8;
        pub const VT_UNDERLYING_TYPE: flatbuffers::VOffsetT = 10;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 12;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 14;
        pub const VT_DECLARATION_FILE: flatbuffers::VOffsetT = 16;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Enum { _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 EnumArgs<'args>,
        ) -> flatbuffers::WIPOffset<Enum<'bldr>> {
            let mut builder = EnumBuilder::new(_fbb);
            if let Some(x) = args.declaration_file {
                builder.add_declaration_file(x);
            }
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            if let Some(x) = args.underlying_type {
                builder.add_underlying_type(x);
            }
            if let Some(x) = args.values {
                builder.add_values(x);
            }
            if let Some(x) = args.name {
                builder.add_name(x);
            }
            builder.add_is_union(args.is_union);
            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>>(Enum::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &Enum) -> bool {
            self.name() < o.name()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.name();
            key.cmp(val)
        }
        #[inline]
        pub fn values(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<EnumVal<'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<EnumVal>>,
                    >>(Enum::VT_VALUES, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn is_union(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Enum::VT_IS_UNION, Some(false)).unwrap() }
        }
        #[inline]
        pub fn underlying_type(&self) -> Type<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<flatbuffers::ForwardsUOffset<Type>>(Enum::VT_UNDERLYING_TYPE, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(Enum::VT_ATTRIBUTES, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(Enum::VT_DOCUMENTATION, None)
            }
        }
        /// File that this Enum is declared in.
        #[inline]
        pub fn declaration_file(&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>>(Enum::VT_DECLARATION_FILE, None)
            }
        }
    }

    impl flatbuffers::Verifiable for Enum<'_> {
        #[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<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<EnumVal>>,
                >>("values", Self::VT_VALUES, true)?
                .visit_field::<bool>("is_union", Self::VT_IS_UNION, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<Type>>(
                    "underlying_type",
                    Self::VT_UNDERLYING_TYPE,
                    true,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                    "declaration_file",
                    Self::VT_DECLARATION_FILE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct EnumArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub values: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<EnumVal<'a>>>,
            >,
        >,
        pub is_union: bool,
        pub underlying_type: Option<flatbuffers::WIPOffset<Type<'a>>>,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
        pub declaration_file: Option<flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for EnumArgs<'a> {
        #[inline]
        fn default() -> Self {
            EnumArgs {
                name: None,   // required field
                values: None, // required field
                is_union: false,
                underlying_type: None, // required field
                attributes: None,
                documentation: None,
                declaration_file: None,
            }
        }
    }

    pub struct EnumBuilder<'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> EnumBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Enum::VT_NAME, name);
        }
        #[inline]
        pub fn add_values(
            &mut self,
            values: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<EnumVal<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Enum::VT_VALUES, values);
        }
        #[inline]
        pub fn add_is_union(&mut self, is_union: bool) {
            self.fbb_.push_slot::<bool>(Enum::VT_IS_UNION, is_union, false);
        }
        #[inline]
        pub fn add_underlying_type(&mut self, underlying_type: flatbuffers::WIPOffset<Type<'b>>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Type>>(
                Enum::VT_UNDERLYING_TYPE,
                underlying_type,
            );
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Enum::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Enum::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn add_declaration_file(&mut self, declaration_file: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Enum::VT_DECLARATION_FILE,
                declaration_file,
            );
        }
        #[inline]
        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> EnumBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            EnumBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Enum<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, Enum::VT_NAME, "name");
            self.fbb_.required(o, Enum::VT_VALUES, "values");
            self.fbb_.required(o, Enum::VT_UNDERLYING_TYPE, "underlying_type");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl core::fmt::Debug for Enum<'_> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            let mut ds = f.debug_struct("Enum");
            ds.field("name", &self.name());
            ds.field("values", &self.values());
            ds.field("is_union", &self.is_union());
            ds.field("underlying_type", &self.underlying_type());
            ds.field("attributes", &self.attributes());
            ds.field("documentation", &self.documentation());
            ds.field("declaration_file", &self.declaration_file());
            ds.finish()
        }
    }
    pub enum FieldOffset {}
    #[derive(Copy, Clone, PartialEq)]

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

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

    impl<'a> Field<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
        pub const VT_ID: flatbuffers::VOffsetT = 8;
        pub const VT_OFFSET: flatbuffers::VOffsetT = 10;
        pub const VT_DEFAULT_INTEGER: flatbuffers::VOffsetT = 12;
        pub const VT_DEFAULT_REAL: flatbuffers::VOffsetT = 14;
        pub const VT_DEPRECATED: flatbuffers::VOffsetT = 16;
        pub const VT_REQUIRED: flatbuffers::VOffsetT = 18;
        pub const VT_KEY: flatbuffers::VOffsetT = 20;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 22;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 24;
        pub const VT_OPTIONAL: flatbuffers::VOffsetT = 26;
        pub const VT_PADDING: flatbuffers::VOffsetT = 28;
        pub const VT_OFFSET64: flatbuffers::VOffsetT = 30;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Field { _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 FieldArgs<'args>,
        ) -> flatbuffers::WIPOffset<Field<'bldr>> {
            let mut builder = FieldBuilder::new(_fbb);
            builder.add_default_real(args.default_real);
            builder.add_default_integer(args.default_integer);
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            if let Some(x) = args.type_ {
                builder.add_type_(x);
            }
            if let Some(x) = args.name {
                builder.add_name(x);
            }
            builder.add_padding(args.padding);
            builder.add_offset(args.offset);
            builder.add_id(args.id);
            builder.add_offset64(args.offset64);
            builder.add_optional(args.optional);
            builder.add_key(args.key);
            builder.add_required(args.required);
            builder.add_deprecated(args.deprecated);
            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>>(Field::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &Field) -> bool {
            self.name() < o.name()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.name();
            key.cmp(val)
        }
        #[inline]
        pub fn type_(&self) -> Type<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<flatbuffers::ForwardsUOffset<Type>>(Field::VT_TYPE_, None).unwrap()
            }
        }
        #[inline]
        pub fn id(&self) -> u16 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u16>(Field::VT_ID, Some(0)).unwrap() }
        }
        #[inline]
        pub fn offset(&self) -> u16 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u16>(Field::VT_OFFSET, Some(0)).unwrap() }
        }
        #[inline]
        pub fn default_integer(&self) -> i64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i64>(Field::VT_DEFAULT_INTEGER, Some(0)).unwrap() }
        }
        #[inline]
        pub fn default_real(&self) -> f64 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<f64>(Field::VT_DEFAULT_REAL, Some(0.0)).unwrap() }
        }
        #[inline]
        pub fn deprecated(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Field::VT_DEPRECATED, Some(false)).unwrap() }
        }
        #[inline]
        pub fn required(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Field::VT_REQUIRED, Some(false)).unwrap() }
        }
        #[inline]
        pub fn key(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Field::VT_KEY, Some(false)).unwrap() }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(Field::VT_ATTRIBUTES, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(Field::VT_DOCUMENTATION, None)
            }
        }
        #[inline]
        pub fn optional(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Field::VT_OPTIONAL, Some(false)).unwrap() }
        }
        /// Number of padding octets to always add after this field. Structs only.
        #[inline]
        pub fn padding(&self) -> u16 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<u16>(Field::VT_PADDING, Some(0)).unwrap() }
        }
        /// If the field uses 64-bit offsets.
        #[inline]
        pub fn offset64(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Field::VT_OFFSET64, Some(false)).unwrap() }
        }
    }

    impl flatbuffers::Verifiable for Field<'_> {
        #[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<Type>>("type_", Self::VT_TYPE_, true)?
                .visit_field::<u16>("id", Self::VT_ID, false)?
                .visit_field::<u16>("offset", Self::VT_OFFSET, false)?
                .visit_field::<i64>("default_integer", Self::VT_DEFAULT_INTEGER, false)?
                .visit_field::<f64>("default_real", Self::VT_DEFAULT_REAL, false)?
                .visit_field::<bool>("deprecated", Self::VT_DEPRECATED, false)?
                .visit_field::<bool>("required", Self::VT_REQUIRED, false)?
                .visit_field::<bool>("key", Self::VT_KEY, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .visit_field::<bool>("optional", Self::VT_OPTIONAL, false)?
                .visit_field::<u16>("padding", Self::VT_PADDING, false)?
                .visit_field::<bool>("offset64", Self::VT_OFFSET64, false)?
                .finish();
            Ok(())
        }
    }
    pub struct FieldArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub type_: Option<flatbuffers::WIPOffset<Type<'a>>>,
        pub id: u16,
        pub offset: u16,
        pub default_integer: i64,
        pub default_real: f64,
        pub deprecated: bool,
        pub required: bool,
        pub key: bool,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
        pub optional: bool,
        pub padding: u16,
        pub offset64: bool,
    }
    impl<'a> Default for FieldArgs<'a> {
        #[inline]
        fn default() -> Self {
            FieldArgs {
                name: None,  // required field
                type_: None, // required field
                id: 0,
                offset: 0,
                default_integer: 0,
                default_real: 0.0,
                deprecated: false,
                required: false,
                key: false,
                attributes: None,
                documentation: None,
                optional: false,
                padding: 0,
                offset64: false,
            }
        }
    }

    pub struct FieldBuilder<'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> FieldBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Field::VT_NAME, name);
        }
        #[inline]
        pub fn add_type_(&mut self, type_: flatbuffers::WIPOffset<Type<'b>>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Type>>(Field::VT_TYPE_, type_);
        }
        #[inline]
        pub fn add_id(&mut self, id: u16) {
            self.fbb_.push_slot::<u16>(Field::VT_ID, id, 0);
        }
        #[inline]
        pub fn add_offset(&mut self, offset: u16) {
            self.fbb_.push_slot::<u16>(Field::VT_OFFSET, offset, 0);
        }
        #[inline]
        pub fn add_default_integer(&mut self, default_integer: i64) {
            self.fbb_.push_slot::<i64>(Field::VT_DEFAULT_INTEGER, default_integer, 0);
        }
        #[inline]
        pub fn add_default_real(&mut self, default_real: f64) {
            self.fbb_.push_slot::<f64>(Field::VT_DEFAULT_REAL, default_real, 0.0);
        }
        #[inline]
        pub fn add_deprecated(&mut self, deprecated: bool) {
            self.fbb_.push_slot::<bool>(Field::VT_DEPRECATED, deprecated, false);
        }
        #[inline]
        pub fn add_required(&mut self, required: bool) {
            self.fbb_.push_slot::<bool>(Field::VT_REQUIRED, required, false);
        }
        #[inline]
        pub fn add_key(&mut self, key: bool) {
            self.fbb_.push_slot::<bool>(Field::VT_KEY, key, false);
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Field::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Field::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn add_optional(&mut self, optional: bool) {
            self.fbb_.push_slot::<bool>(Field::VT_OPTIONAL, optional, false);
        }
        #[inline]
        pub fn add_padding(&mut self, padding: u16) {
            self.fbb_.push_slot::<u16>(Field::VT_PADDING, padding, 0);
        }
        #[inline]
        pub fn add_offset64(&mut self, offset64: bool) {
            self.fbb_.push_slot::<bool>(Field::VT_OFFSET64, offset64, false);
        }
        #[inline]
        pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FieldBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            FieldBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Field<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, Field::VT_NAME, "name");
            self.fbb_.required(o, Field::VT_TYPE_, "type_");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl core::fmt::Debug for Field<'_> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            let mut ds = f.debug_struct("Field");
            ds.field("name", &self.name());
            ds.field("type_", &self.type_());
            ds.field("id", &self.id());
            ds.field("offset", &self.offset());
            ds.field("default_integer", &self.default_integer());
            ds.field("default_real", &self.default_real());
            ds.field("deprecated", &self.deprecated());
            ds.field("required", &self.required());
            ds.field("key", &self.key());
            ds.field("attributes", &self.attributes());
            ds.field("documentation", &self.documentation());
            ds.field("optional", &self.optional());
            ds.field("padding", &self.padding());
            ds.field("offset64", &self.offset64());
            ds.finish()
        }
    }
    pub enum ObjectOffset {}
    #[derive(Copy, Clone, PartialEq)]

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

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

    impl<'a> Object<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_FIELDS: flatbuffers::VOffsetT = 6;
        pub const VT_IS_STRUCT: flatbuffers::VOffsetT = 8;
        pub const VT_MINALIGN: flatbuffers::VOffsetT = 10;
        pub const VT_BYTESIZE: flatbuffers::VOffsetT = 12;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 14;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 16;
        pub const VT_DECLARATION_FILE: flatbuffers::VOffsetT = 18;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Object { _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 ObjectArgs<'args>,
        ) -> flatbuffers::WIPOffset<Object<'bldr>> {
            let mut builder = ObjectBuilder::new(_fbb);
            if let Some(x) = args.declaration_file {
                builder.add_declaration_file(x);
            }
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            builder.add_bytesize(args.bytesize);
            builder.add_minalign(args.minalign);
            if let Some(x) = args.fields {
                builder.add_fields(x);
            }
            if let Some(x) = args.name {
                builder.add_name(x);
            }
            builder.add_is_struct(args.is_struct);
            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>>(Object::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &Object) -> bool {
            self.name() < o.name()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.name();
            key.cmp(val)
        }
        #[inline]
        pub fn fields(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'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<Field>>,
                    >>(Object::VT_FIELDS, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn is_struct(&self) -> bool {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<bool>(Object::VT_IS_STRUCT, Some(false)).unwrap() }
        }
        #[inline]
        pub fn minalign(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i32>(Object::VT_MINALIGN, Some(0)).unwrap() }
        }
        #[inline]
        pub fn bytesize(&self) -> i32 {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe { self._tab.get::<i32>(Object::VT_BYTESIZE, Some(0)).unwrap() }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(Object::VT_ATTRIBUTES, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(Object::VT_DOCUMENTATION, None)
            }
        }
        /// File that this Object is declared in.
        #[inline]
        pub fn declaration_file(&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>>(Object::VT_DECLARATION_FILE, None)
            }
        }
    }

    impl flatbuffers::Verifiable for Object<'_> {
        #[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<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Field>>,
                >>("fields", Self::VT_FIELDS, true)?
                .visit_field::<bool>("is_struct", Self::VT_IS_STRUCT, false)?
                .visit_field::<i32>("minalign", Self::VT_MINALIGN, false)?
                .visit_field::<i32>("bytesize", Self::VT_BYTESIZE, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                    "declaration_file",
                    Self::VT_DECLARATION_FILE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ObjectArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub fields: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>,
            >,
        >,
        pub is_struct: bool,
        pub minalign: i32,
        pub bytesize: i32,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
        pub declaration_file: Option<flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ObjectArgs<'a> {
        #[inline]
        fn default() -> Self {
            ObjectArgs {
                name: None,   // required field
                fields: None, // required field
                is_struct: false,
                minalign: 0,
                bytesize: 0,
                attributes: None,
                documentation: None,
                declaration_file: None,
            }
        }
    }

    pub struct ObjectBuilder<'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> ObjectBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Object::VT_NAME, name);
        }
        #[inline]
        pub fn add_fields(
            &mut self,
            fields: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<Field<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Object::VT_FIELDS, fields);
        }
        #[inline]
        pub fn add_is_struct(&mut self, is_struct: bool) {
            self.fbb_.push_slot::<bool>(Object::VT_IS_STRUCT, is_struct, false);
        }
        #[inline]
        pub fn add_minalign(&mut self, minalign: i32) {
            self.fbb_.push_slot::<i32>(Object::VT_MINALIGN, minalign, 0);
        }
        #[inline]
        pub fn add_bytesize(&mut self, bytesize: i32) {
            self.fbb_.push_slot::<i32>(Object::VT_BYTESIZE, bytesize, 0);
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Object::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Object::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn add_declaration_file(&mut self, declaration_file: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Object::VT_DECLARATION_FILE,
                declaration_file,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ObjectBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ObjectBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Object<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, Object::VT_NAME, "name");
            self.fbb_.required(o, Object::VT_FIELDS, "fields");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl core::fmt::Debug for Object<'_> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            let mut ds = f.debug_struct("Object");
            ds.field("name", &self.name());
            ds.field("fields", &self.fields());
            ds.field("is_struct", &self.is_struct());
            ds.field("minalign", &self.minalign());
            ds.field("bytesize", &self.bytesize());
            ds.field("attributes", &self.attributes());
            ds.field("documentation", &self.documentation());
            ds.field("declaration_file", &self.declaration_file());
            ds.finish()
        }
    }
    pub enum RPCCallOffset {}
    #[derive(Copy, Clone, PartialEq)]

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

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

    impl<'a> RPCCall<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_REQUEST: flatbuffers::VOffsetT = 6;
        pub const VT_RESPONSE: flatbuffers::VOffsetT = 8;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 10;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            RPCCall { _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 RPCCallArgs<'args>,
        ) -> flatbuffers::WIPOffset<RPCCall<'bldr>> {
            let mut builder = RPCCallBuilder::new(_fbb);
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            if let Some(x) = args.response {
                builder.add_response(x);
            }
            if let Some(x) = args.request {
                builder.add_request(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>>(RPCCall::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &RPCCall) -> bool {
            self.name() < o.name()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.name();
            key.cmp(val)
        }
        #[inline]
        pub fn request(&self) -> Object<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<flatbuffers::ForwardsUOffset<Object>>(RPCCall::VT_REQUEST, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn response(&self) -> Object<'a> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<flatbuffers::ForwardsUOffset<Object>>(RPCCall::VT_RESPONSE, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(RPCCall::VT_ATTRIBUTES, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(RPCCall::VT_DOCUMENTATION, None)
            }
        }
    }

    impl flatbuffers::Verifiable for RPCCall<'_> {
        #[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<Object>>(
                    "request",
                    Self::VT_REQUEST,
                    true,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<Object>>(
                    "response",
                    Self::VT_RESPONSE,
                    true,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .finish();
            Ok(())
        }
    }
    pub struct RPCCallArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub request: Option<flatbuffers::WIPOffset<Object<'a>>>,
        pub response: Option<flatbuffers::WIPOffset<Object<'a>>>,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
    }
    impl<'a> Default for RPCCallArgs<'a> {
        #[inline]
        fn default() -> Self {
            RPCCallArgs {
                name: None,     // required field
                request: None,  // required field
                response: None, // required field
                attributes: None,
                documentation: None,
            }
        }
    }

    pub struct RPCCallBuilder<'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> RPCCallBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RPCCall::VT_NAME, name);
        }
        #[inline]
        pub fn add_request(&mut self, request: flatbuffers::WIPOffset<Object<'b>>) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<Object>>(RPCCall::VT_REQUEST, request);
        }
        #[inline]
        pub fn add_response(&mut self, response: flatbuffers::WIPOffset<Object<'b>>) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<Object>>(RPCCall::VT_RESPONSE, response);
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(RPCCall::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                RPCCall::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> RPCCallBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            RPCCallBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<RPCCall<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, RPCCall::VT_NAME, "name");
            self.fbb_.required(o, RPCCall::VT_REQUEST, "request");
            self.fbb_.required(o, RPCCall::VT_RESPONSE, "response");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

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

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

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

    impl<'a> Service<'a> {
        pub const VT_NAME: flatbuffers::VOffsetT = 4;
        pub const VT_CALLS: flatbuffers::VOffsetT = 6;
        pub const VT_ATTRIBUTES: flatbuffers::VOffsetT = 8;
        pub const VT_DOCUMENTATION: flatbuffers::VOffsetT = 10;
        pub const VT_DECLARATION_FILE: flatbuffers::VOffsetT = 12;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Service { _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 ServiceArgs<'args>,
        ) -> flatbuffers::WIPOffset<Service<'bldr>> {
            let mut builder = ServiceBuilder::new(_fbb);
            if let Some(x) = args.declaration_file {
                builder.add_declaration_file(x);
            }
            if let Some(x) = args.documentation {
                builder.add_documentation(x);
            }
            if let Some(x) = args.attributes {
                builder.add_attributes(x);
            }
            if let Some(x) = args.calls {
                builder.add_calls(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>>(Service::VT_NAME, None).unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &Service) -> bool {
            self.name() < o.name()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.name();
            key.cmp(val)
        }
        #[inline]
        pub fn calls(
            &self,
        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RPCCall<'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<RPCCall>>,
                >>(Service::VT_CALLS, None)
            }
        }
        #[inline]
        pub fn attributes(
            &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>>,
                >>(Service::VT_ATTRIBUTES, None)
            }
        }
        #[inline]
        pub fn documentation(
            &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>>,
                >>(Service::VT_DOCUMENTATION, None)
            }
        }
        /// File that this Service is declared in.
        #[inline]
        pub fn declaration_file(&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>>(Service::VT_DECLARATION_FILE, None)
            }
        }
    }

    impl flatbuffers::Verifiable for Service<'_> {
        #[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<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RPCCall>>,
                >>("calls", Self::VT_CALLS, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
                >>("attributes", Self::VT_ATTRIBUTES, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("documentation", Self::VT_DOCUMENTATION, false)?
                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                    "declaration_file",
                    Self::VT_DECLARATION_FILE,
                    false,
                )?
                .finish();
            Ok(())
        }
    }
    pub struct ServiceArgs<'a> {
        pub name: Option<flatbuffers::WIPOffset<&'a str>>,
        pub calls: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RPCCall<'a>>>,
            >,
        >,
        pub attributes: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
            >,
        >,
        pub documentation: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
        pub declaration_file: Option<flatbuffers::WIPOffset<&'a str>>,
    }
    impl<'a> Default for ServiceArgs<'a> {
        #[inline]
        fn default() -> Self {
            ServiceArgs {
                name: None, // required field
                calls: None,
                attributes: None,
                documentation: None,
                declaration_file: None,
            }
        }
    }

    pub struct ServiceBuilder<'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> ServiceBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Service::VT_NAME, name);
        }
        #[inline]
        pub fn add_calls(
            &mut self,
            calls: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<RPCCall<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Service::VT_CALLS, calls);
        }
        #[inline]
        pub fn add_attributes(
            &mut self,
            attributes: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<KeyValue<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Service::VT_ATTRIBUTES, attributes);
        }
        #[inline]
        pub fn add_documentation(
            &mut self,
            documentation: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Service::VT_DOCUMENTATION,
                documentation,
            );
        }
        #[inline]
        pub fn add_declaration_file(&mut self, declaration_file: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                Service::VT_DECLARATION_FILE,
                declaration_file,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> ServiceBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            ServiceBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Service<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, Service::VT_NAME, "name");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

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

    /// File specific information.
    /// Symbols declared within a file may be recovered by iterating over all
    /// symbols and examining the `declaration_file` field.
    pub struct SchemaFile<'a> {
        pub _tab: flatbuffers::Table<'a>,
    }

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

    impl<'a> SchemaFile<'a> {
        pub const VT_FILENAME: flatbuffers::VOffsetT = 4;
        pub const VT_INCLUDED_FILENAMES: flatbuffers::VOffsetT = 6;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            SchemaFile { _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 SchemaFileArgs<'args>,
        ) -> flatbuffers::WIPOffset<SchemaFile<'bldr>> {
            let mut builder = SchemaFileBuilder::new(_fbb);
            if let Some(x) = args.included_filenames {
                builder.add_included_filenames(x);
            }
            if let Some(x) = args.filename {
                builder.add_filename(x);
            }
            builder.finish()
        }

        /// Filename, relative to project root.
        #[inline]
        pub fn filename(&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>>(SchemaFile::VT_FILENAME, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn key_compare_less_than(&self, o: &SchemaFile) -> bool {
            self.filename() < o.filename()
        }

        #[inline]
        pub fn key_compare_with_value(&self, val: &str) -> ::core::cmp::Ordering {
            let key = self.filename();
            key.cmp(val)
        }
        /// Names of included files, relative to project root.
        #[inline]
        pub fn included_filenames(
            &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>>,
                >>(SchemaFile::VT_INCLUDED_FILENAMES, None)
            }
        }
    }

    impl flatbuffers::Verifiable for SchemaFile<'_> {
        #[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>>(
                    "filename",
                    Self::VT_FILENAME,
                    true,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>,
                >>("included_filenames", Self::VT_INCLUDED_FILENAMES, false)?
                .finish();
            Ok(())
        }
    }
    pub struct SchemaFileArgs<'a> {
        pub filename: Option<flatbuffers::WIPOffset<&'a str>>,
        pub included_filenames: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>,
        >,
    }
    impl<'a> Default for SchemaFileArgs<'a> {
        #[inline]
        fn default() -> Self {
            SchemaFileArgs {
                filename: None, // required field
                included_filenames: None,
            }
        }
    }

    pub struct SchemaFileBuilder<'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> SchemaFileBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_filename(&mut self, filename: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(SchemaFile::VT_FILENAME, filename);
        }
        #[inline]
        pub fn add_included_filenames(
            &mut self,
            included_filenames: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
                SchemaFile::VT_INCLUDED_FILENAMES,
                included_filenames,
            );
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> SchemaFileBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            SchemaFileBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<SchemaFile<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, SchemaFile::VT_FILENAME, "filename");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

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

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

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

    impl<'a> Schema<'a> {
        pub const VT_OBJECTS: flatbuffers::VOffsetT = 4;
        pub const VT_ENUMS: flatbuffers::VOffsetT = 6;
        pub const VT_FILE_IDENT: flatbuffers::VOffsetT = 8;
        pub const VT_FILE_EXT: flatbuffers::VOffsetT = 10;
        pub const VT_ROOT_TABLE: flatbuffers::VOffsetT = 12;
        pub const VT_SERVICES: flatbuffers::VOffsetT = 14;
        pub const VT_ADVANCED_FEATURES: flatbuffers::VOffsetT = 16;
        pub const VT_FBS_FILES: flatbuffers::VOffsetT = 18;

        #[inline]
        pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
            Schema { _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 SchemaArgs<'args>,
        ) -> flatbuffers::WIPOffset<Schema<'bldr>> {
            let mut builder = SchemaBuilder::new(_fbb);
            builder.add_advanced_features(args.advanced_features);
            if let Some(x) = args.fbs_files {
                builder.add_fbs_files(x);
            }
            if let Some(x) = args.services {
                builder.add_services(x);
            }
            if let Some(x) = args.root_table {
                builder.add_root_table(x);
            }
            if let Some(x) = args.file_ext {
                builder.add_file_ext(x);
            }
            if let Some(x) = args.file_ident {
                builder.add_file_ident(x);
            }
            if let Some(x) = args.enums {
                builder.add_enums(x);
            }
            if let Some(x) = args.objects {
                builder.add_objects(x);
            }
            builder.finish()
        }

        #[inline]
        pub fn objects(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Object<'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<Object>>,
                    >>(Schema::VT_OBJECTS, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn enums(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Enum<'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<Enum>>,
                    >>(Schema::VT_ENUMS, None)
                    .unwrap()
            }
        }
        #[inline]
        pub fn file_ident(&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>>(Schema::VT_FILE_IDENT, None)
            }
        }
        #[inline]
        pub fn file_ext(&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>>(Schema::VT_FILE_EXT, None)
            }
        }
        #[inline]
        pub fn root_table(&self) -> Option<Object<'a>> {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab.get::<flatbuffers::ForwardsUOffset<Object>>(Schema::VT_ROOT_TABLE, None)
            }
        }
        #[inline]
        pub fn services(
            &self,
        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Service<'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<Service>>,
                >>(Schema::VT_SERVICES, None)
            }
        }
        #[inline]
        pub fn advanced_features(&self) -> AdvancedFeatures {
            // Safety:
            // Created from valid Table for this object
            // which contains a valid value in this slot
            unsafe {
                self._tab
                    .get::<AdvancedFeatures>(Schema::VT_ADVANCED_FEATURES, Some(Default::default()))
                    .unwrap()
            }
        }
        /// All the files used in this compilation. Files are relative to where
        /// flatc was invoked.
        #[inline]
        pub fn fbs_files(
            &self,
        ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SchemaFile<'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<SchemaFile>>,
                >>(Schema::VT_FBS_FILES, None)
            }
        }
    }

    impl flatbuffers::Verifiable for Schema<'_> {
        #[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<Object>>,
                >>("objects", Self::VT_OBJECTS, true)?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Enum>>,
                >>("enums", Self::VT_ENUMS, true)?
                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                    "file_ident",
                    Self::VT_FILE_IDENT,
                    false,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
                    "file_ext",
                    Self::VT_FILE_EXT,
                    false,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<Object>>(
                    "root_table",
                    Self::VT_ROOT_TABLE,
                    false,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Service>>,
                >>("services", Self::VT_SERVICES, false)?
                .visit_field::<AdvancedFeatures>(
                    "advanced_features",
                    Self::VT_ADVANCED_FEATURES,
                    false,
                )?
                .visit_field::<flatbuffers::ForwardsUOffset<
                    flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<SchemaFile>>,
                >>("fbs_files", Self::VT_FBS_FILES, false)?
                .finish();
            Ok(())
        }
    }
    pub struct SchemaArgs<'a> {
        pub objects: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Object<'a>>>,
            >,
        >,
        pub enums: Option<
            flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Enum<'a>>>>,
        >,
        pub file_ident: Option<flatbuffers::WIPOffset<&'a str>>,
        pub file_ext: Option<flatbuffers::WIPOffset<&'a str>>,
        pub root_table: Option<flatbuffers::WIPOffset<Object<'a>>>,
        pub services: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Service<'a>>>,
            >,
        >,
        pub advanced_features: AdvancedFeatures,
        pub fbs_files: Option<
            flatbuffers::WIPOffset<
                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<SchemaFile<'a>>>,
            >,
        >,
    }
    impl<'a> Default for SchemaArgs<'a> {
        #[inline]
        fn default() -> Self {
            SchemaArgs {
                objects: None, // required field
                enums: None,   // required field
                file_ident: None,
                file_ext: None,
                root_table: None,
                services: None,
                advanced_features: Default::default(),
                fbs_files: None,
            }
        }
    }

    pub struct SchemaBuilder<'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> SchemaBuilder<'a, 'b, A> {
        #[inline]
        pub fn add_objects(
            &mut self,
            objects: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<Object<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_OBJECTS, objects);
        }
        #[inline]
        pub fn add_enums(
            &mut self,
            enums: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<Enum<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_ENUMS, enums);
        }
        #[inline]
        pub fn add_file_ident(&mut self, file_ident: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_FILE_IDENT, file_ident);
        }
        #[inline]
        pub fn add_file_ext(&mut self, file_ext: flatbuffers::WIPOffset<&'b str>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_FILE_EXT, file_ext);
        }
        #[inline]
        pub fn add_root_table(&mut self, root_table: flatbuffers::WIPOffset<Object<'b>>) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Object>>(
                Schema::VT_ROOT_TABLE,
                root_table,
            );
        }
        #[inline]
        pub fn add_services(
            &mut self,
            services: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<Service<'b>>>,
            >,
        ) {
            self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_SERVICES, services);
        }
        #[inline]
        pub fn add_advanced_features(&mut self, advanced_features: AdvancedFeatures) {
            self.fbb_.push_slot::<AdvancedFeatures>(
                Schema::VT_ADVANCED_FEATURES,
                advanced_features,
                Default::default(),
            );
        }
        #[inline]
        pub fn add_fbs_files(
            &mut self,
            fbs_files: flatbuffers::WIPOffset<
                flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<SchemaFile<'b>>>,
            >,
        ) {
            self.fbb_
                .push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_FBS_FILES, fbs_files);
        }
        #[inline]
        pub fn new(
            _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        ) -> SchemaBuilder<'a, 'b, A> {
            let start = _fbb.start_table();
            SchemaBuilder { fbb_: _fbb, start_: start }
        }
        #[inline]
        pub fn finish(self) -> flatbuffers::WIPOffset<Schema<'a>> {
            let o = self.fbb_.end_table(self.start_);
            self.fbb_.required(o, Schema::VT_OBJECTS, "objects");
            self.fbb_.required(o, Schema::VT_ENUMS, "enums");
            flatbuffers::WIPOffset::new(o.value())
        }
    }

    impl core::fmt::Debug for Schema<'_> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            let mut ds = f.debug_struct("Schema");
            ds.field("objects", &self.objects());
            ds.field("enums", &self.enums());
            ds.field("file_ident", &self.file_ident());
            ds.field("file_ext", &self.file_ext());
            ds.field("root_table", &self.root_table());
            ds.field("services", &self.services());
            ds.field("advanced_features", &self.advanced_features());
            ds.field("fbs_files", &self.fbs_files());
            ds.finish()
        }
    }
    #[inline]
    /// Verifies that a buffer of bytes contains a `Schema`
    /// 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_schema_unchecked`.
    pub fn root_as_schema(buf: &[u8]) -> Result<Schema, flatbuffers::InvalidFlatbuffer> {
        flatbuffers::root::<Schema>(buf)
    }
    #[inline]
    /// Verifies that a buffer of bytes contains a size prefixed
    /// `Schema` 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_schema_unchecked`.
    pub fn size_prefixed_root_as_schema(
        buf: &[u8],
    ) -> Result<Schema, flatbuffers::InvalidFlatbuffer> {
        flatbuffers::size_prefixed_root::<Schema>(buf)
    }
    #[inline]
    /// Verifies, with the given options, that a buffer of bytes
    /// contains a `Schema` 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_schema_unchecked`.
    pub fn root_as_schema_with_opts<'b, 'o>(
        opts: &'o flatbuffers::VerifierOptions,
        buf: &'b [u8],
    ) -> Result<Schema<'b>, flatbuffers::InvalidFlatbuffer> {
        flatbuffers::root_with_opts::<Schema<'b>>(opts, buf)
    }
    #[inline]
    /// Verifies, with the given verifier options, that a buffer of
    /// bytes contains a size prefixed `Schema` 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_schema_unchecked`.
    pub fn size_prefixed_root_as_schema_with_opts<'b, 'o>(
        opts: &'o flatbuffers::VerifierOptions,
        buf: &'b [u8],
    ) -> Result<Schema<'b>, flatbuffers::InvalidFlatbuffer> {
        flatbuffers::size_prefixed_root_with_opts::<Schema<'b>>(opts, buf)
    }
    #[inline]
    /// Assumes, without verification, that a buffer of bytes contains a Schema and returns it.
    /// # Safety
    /// Callers must trust the given bytes do indeed contain a valid `Schema`.
    pub unsafe fn root_as_schema_unchecked(buf: &[u8]) -> Schema {
        flatbuffers::root_unchecked::<Schema>(buf)
    }
    #[inline]
    /// Assumes, without verification, that a buffer of bytes contains a size prefixed Schema and returns it.
    /// # Safety
    /// Callers must trust the given bytes do indeed contain a valid size prefixed `Schema`.
    pub unsafe fn size_prefixed_root_as_schema_unchecked(buf: &[u8]) -> Schema {
        flatbuffers::size_prefixed_root_unchecked::<Schema>(buf)
    }
    pub const SCHEMA_IDENTIFIER: &str = "BFBS";

    #[inline]
    pub fn schema_buffer_has_identifier(buf: &[u8]) -> bool {
        flatbuffers::buffer_has_identifier(buf, SCHEMA_IDENTIFIER, false)
    }

    #[inline]
    pub fn schema_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
        flatbuffers::buffer_has_identifier(buf, SCHEMA_IDENTIFIER, true)
    }

    pub const SCHEMA_EXTENSION: &str = "bfbs";

    #[inline]
    pub fn finish_schema_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        root: flatbuffers::WIPOffset<Schema<'a>>,
    ) {
        fbb.finish(root, Some(SCHEMA_IDENTIFIER));
    }

    #[inline]
    pub fn finish_size_prefixed_schema_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
        fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
        root: flatbuffers::WIPOffset<Schema<'a>>,
    ) {
        fbb.finish_size_prefixed(root, Some(SCHEMA_IDENTIFIER));
    }
} // pub mod reflection