yara-x 1.15.0

// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by pure
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `dotnet.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;

// @@protoc_insertion_point(message:dotnet.Dotnet)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Dotnet {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Dotnet.is_dotnet)
    pub is_dotnet: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.module_name)
    pub module_name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.version)
    pub version: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_streams)
    pub number_of_streams: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_guids)
    pub number_of_guids: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_resources)
    pub number_of_resources: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_generic_parameters)
    pub number_of_generic_parameters: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_classes)
    pub number_of_classes: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_assembly_refs)
    pub number_of_assembly_refs: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_modulerefs)
    pub number_of_modulerefs: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_user_strings)
    pub number_of_user_strings: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_constants)
    pub number_of_constants: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.number_of_field_offsets)
    pub number_of_field_offsets: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.typelib)
    pub typelib: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.streams)
    pub streams: ::std::vec::Vec<Stream>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.guids)
    pub guids: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.constants)
    pub constants: ::std::vec::Vec<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.assembly)
    pub assembly: ::protobuf::MessageField<Assembly>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.assembly_refs)
    pub assembly_refs: ::std::vec::Vec<AssemblyRef>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.resources)
    pub resources: ::std::vec::Vec<Resource>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.classes)
    pub classes: ::std::vec::Vec<Class>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.field_offsets)
    pub field_offsets: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.user_strings)
    pub user_strings: ::std::vec::Vec<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:dotnet.Dotnet.modulerefs)
    pub modulerefs: ::std::vec::Vec<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Dotnet.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Dotnet {
    fn default() -> &'a Dotnet {
        <Dotnet as ::protobuf::Message>::default_instance()
    }
}

impl Dotnet {
    pub fn new() -> Dotnet {
        ::std::default::Default::default()
    }

    // optional bool is_dotnet = 1;

    pub fn is_dotnet(&self) -> bool {
        self.is_dotnet.unwrap_or(false)
    }

    pub fn clear_is_dotnet(&mut self) {
        self.is_dotnet = ::std::option::Option::None;
    }

    pub fn has_is_dotnet(&self) -> bool {
        self.is_dotnet.is_some()
    }

    // Param is passed by value, moved
    pub fn set_is_dotnet(&mut self, v: bool) {
        self.is_dotnet = ::std::option::Option::Some(v);
    }

    // optional string module_name = 2;

    pub fn module_name(&self) -> &str {
        match self.module_name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_module_name(&mut self) {
        self.module_name = ::std::option::Option::None;
    }

    pub fn has_module_name(&self) -> bool {
        self.module_name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_module_name(&mut self, v: ::std::string::String) {
        self.module_name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_module_name(&mut self) -> &mut ::std::string::String {
        if self.module_name.is_none() {
            self.module_name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.module_name.as_mut().unwrap()
    }

    // Take field
    pub fn take_module_name(&mut self) -> ::std::string::String {
        self.module_name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string version = 3;

    pub fn version(&self) -> &str {
        match self.version.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_version(&mut self) {
        self.version = ::std::option::Option::None;
    }

    pub fn has_version(&self) -> bool {
        self.version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: ::std::string::String) {
        self.version = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_version(&mut self) -> &mut ::std::string::String {
        if self.version.is_none() {
            self.version = ::std::option::Option::Some(::std::string::String::new());
        }
        self.version.as_mut().unwrap()
    }

    // Take field
    pub fn take_version(&mut self) -> ::std::string::String {
        self.version.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional uint64 number_of_streams = 4;

    pub fn number_of_streams(&self) -> u64 {
        self.number_of_streams.unwrap_or(0)
    }

    pub fn clear_number_of_streams(&mut self) {
        self.number_of_streams = ::std::option::Option::None;
    }

    pub fn has_number_of_streams(&self) -> bool {
        self.number_of_streams.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_streams(&mut self, v: u64) {
        self.number_of_streams = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_guids = 5;

    pub fn number_of_guids(&self) -> u64 {
        self.number_of_guids.unwrap_or(0)
    }

    pub fn clear_number_of_guids(&mut self) {
        self.number_of_guids = ::std::option::Option::None;
    }

    pub fn has_number_of_guids(&self) -> bool {
        self.number_of_guids.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_guids(&mut self, v: u64) {
        self.number_of_guids = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_resources = 6;

    pub fn number_of_resources(&self) -> u64 {
        self.number_of_resources.unwrap_or(0)
    }

    pub fn clear_number_of_resources(&mut self) {
        self.number_of_resources = ::std::option::Option::None;
    }

    pub fn has_number_of_resources(&self) -> bool {
        self.number_of_resources.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_resources(&mut self, v: u64) {
        self.number_of_resources = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_generic_parameters = 7;

    pub fn number_of_generic_parameters(&self) -> u64 {
        self.number_of_generic_parameters.unwrap_or(0)
    }

    pub fn clear_number_of_generic_parameters(&mut self) {
        self.number_of_generic_parameters = ::std::option::Option::None;
    }

    pub fn has_number_of_generic_parameters(&self) -> bool {
        self.number_of_generic_parameters.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_generic_parameters(&mut self, v: u64) {
        self.number_of_generic_parameters = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_classes = 10;

    pub fn number_of_classes(&self) -> u64 {
        self.number_of_classes.unwrap_or(0)
    }

    pub fn clear_number_of_classes(&mut self) {
        self.number_of_classes = ::std::option::Option::None;
    }

    pub fn has_number_of_classes(&self) -> bool {
        self.number_of_classes.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_classes(&mut self, v: u64) {
        self.number_of_classes = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_assembly_refs = 11;

    pub fn number_of_assembly_refs(&self) -> u64 {
        self.number_of_assembly_refs.unwrap_or(0)
    }

    pub fn clear_number_of_assembly_refs(&mut self) {
        self.number_of_assembly_refs = ::std::option::Option::None;
    }

    pub fn has_number_of_assembly_refs(&self) -> bool {
        self.number_of_assembly_refs.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_assembly_refs(&mut self, v: u64) {
        self.number_of_assembly_refs = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_modulerefs = 12;

    pub fn number_of_modulerefs(&self) -> u64 {
        self.number_of_modulerefs.unwrap_or(0)
    }

    pub fn clear_number_of_modulerefs(&mut self) {
        self.number_of_modulerefs = ::std::option::Option::None;
    }

    pub fn has_number_of_modulerefs(&self) -> bool {
        self.number_of_modulerefs.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_modulerefs(&mut self, v: u64) {
        self.number_of_modulerefs = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_user_strings = 13;

    pub fn number_of_user_strings(&self) -> u64 {
        self.number_of_user_strings.unwrap_or(0)
    }

    pub fn clear_number_of_user_strings(&mut self) {
        self.number_of_user_strings = ::std::option::Option::None;
    }

    pub fn has_number_of_user_strings(&self) -> bool {
        self.number_of_user_strings.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_user_strings(&mut self, v: u64) {
        self.number_of_user_strings = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_constants = 14;

    pub fn number_of_constants(&self) -> u64 {
        self.number_of_constants.unwrap_or(0)
    }

    pub fn clear_number_of_constants(&mut self) {
        self.number_of_constants = ::std::option::Option::None;
    }

    pub fn has_number_of_constants(&self) -> bool {
        self.number_of_constants.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_constants(&mut self, v: u64) {
        self.number_of_constants = ::std::option::Option::Some(v);
    }

    // optional uint64 number_of_field_offsets = 15;

    pub fn number_of_field_offsets(&self) -> u64 {
        self.number_of_field_offsets.unwrap_or(0)
    }

    pub fn clear_number_of_field_offsets(&mut self) {
        self.number_of_field_offsets = ::std::option::Option::None;
    }

    pub fn has_number_of_field_offsets(&self) -> bool {
        self.number_of_field_offsets.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_field_offsets(&mut self, v: u64) {
        self.number_of_field_offsets = ::std::option::Option::Some(v);
    }

    // optional string typelib = 16;

    pub fn typelib(&self) -> &str {
        match self.typelib.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_typelib(&mut self) {
        self.typelib = ::std::option::Option::None;
    }

    pub fn has_typelib(&self) -> bool {
        self.typelib.is_some()
    }

    // Param is passed by value, moved
    pub fn set_typelib(&mut self, v: ::std::string::String) {
        self.typelib = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_typelib(&mut self) -> &mut ::std::string::String {
        if self.typelib.is_none() {
            self.typelib = ::std::option::Option::Some(::std::string::String::new());
        }
        self.typelib.as_mut().unwrap()
    }

    // Take field
    pub fn take_typelib(&mut self) -> ::std::string::String {
        self.typelib.take().unwrap_or_else(|| ::std::string::String::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(24);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "is_dotnet",
            |m: &Dotnet| { &m.is_dotnet },
            |m: &mut Dotnet| { &mut m.is_dotnet },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "module_name",
            |m: &Dotnet| { &m.module_name },
            |m: &mut Dotnet| { &mut m.module_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "version",
            |m: &Dotnet| { &m.version },
            |m: &mut Dotnet| { &mut m.version },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_streams",
            |m: &Dotnet| { &m.number_of_streams },
            |m: &mut Dotnet| { &mut m.number_of_streams },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_guids",
            |m: &Dotnet| { &m.number_of_guids },
            |m: &mut Dotnet| { &mut m.number_of_guids },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_resources",
            |m: &Dotnet| { &m.number_of_resources },
            |m: &mut Dotnet| { &mut m.number_of_resources },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_generic_parameters",
            |m: &Dotnet| { &m.number_of_generic_parameters },
            |m: &mut Dotnet| { &mut m.number_of_generic_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_classes",
            |m: &Dotnet| { &m.number_of_classes },
            |m: &mut Dotnet| { &mut m.number_of_classes },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_assembly_refs",
            |m: &Dotnet| { &m.number_of_assembly_refs },
            |m: &mut Dotnet| { &mut m.number_of_assembly_refs },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_modulerefs",
            |m: &Dotnet| { &m.number_of_modulerefs },
            |m: &mut Dotnet| { &mut m.number_of_modulerefs },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_user_strings",
            |m: &Dotnet| { &m.number_of_user_strings },
            |m: &mut Dotnet| { &mut m.number_of_user_strings },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_constants",
            |m: &Dotnet| { &m.number_of_constants },
            |m: &mut Dotnet| { &mut m.number_of_constants },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_field_offsets",
            |m: &Dotnet| { &m.number_of_field_offsets },
            |m: &mut Dotnet| { &mut m.number_of_field_offsets },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "typelib",
            |m: &Dotnet| { &m.typelib },
            |m: &mut Dotnet| { &mut m.typelib },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "streams",
            |m: &Dotnet| { &m.streams },
            |m: &mut Dotnet| { &mut m.streams },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "guids",
            |m: &Dotnet| { &m.guids },
            |m: &mut Dotnet| { &mut m.guids },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "constants",
            |m: &Dotnet| { &m.constants },
            |m: &mut Dotnet| { &mut m.constants },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Assembly>(
            "assembly",
            |m: &Dotnet| { &m.assembly },
            |m: &mut Dotnet| { &mut m.assembly },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "assembly_refs",
            |m: &Dotnet| { &m.assembly_refs },
            |m: &mut Dotnet| { &mut m.assembly_refs },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "resources",
            |m: &Dotnet| { &m.resources },
            |m: &mut Dotnet| { &mut m.resources },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "classes",
            |m: &Dotnet| { &m.classes },
            |m: &mut Dotnet| { &mut m.classes },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "field_offsets",
            |m: &Dotnet| { &m.field_offsets },
            |m: &mut Dotnet| { &mut m.field_offsets },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "user_strings",
            |m: &Dotnet| { &m.user_strings },
            |m: &mut Dotnet| { &mut m.user_strings },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "modulerefs",
            |m: &Dotnet| { &m.modulerefs },
            |m: &mut Dotnet| { &mut m.modulerefs },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Dotnet>(
            "Dotnet",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Dotnet {
    const NAME: &'static str = "Dotnet";

    fn is_initialized(&self) -> bool {
        for v in &self.streams {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.assembly {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.assembly_refs {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.resources {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.classes {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.is_dotnet = ::std::option::Option::Some(is.read_bool()?);
                },
                18 => {
                    self.module_name = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.version = ::std::option::Option::Some(is.read_string()?);
                },
                32 => {
                    self.number_of_streams = ::std::option::Option::Some(is.read_uint64()?);
                },
                40 => {
                    self.number_of_guids = ::std::option::Option::Some(is.read_uint64()?);
                },
                48 => {
                    self.number_of_resources = ::std::option::Option::Some(is.read_uint64()?);
                },
                56 => {
                    self.number_of_generic_parameters = ::std::option::Option::Some(is.read_uint64()?);
                },
                80 => {
                    self.number_of_classes = ::std::option::Option::Some(is.read_uint64()?);
                },
                88 => {
                    self.number_of_assembly_refs = ::std::option::Option::Some(is.read_uint64()?);
                },
                96 => {
                    self.number_of_modulerefs = ::std::option::Option::Some(is.read_uint64()?);
                },
                104 => {
                    self.number_of_user_strings = ::std::option::Option::Some(is.read_uint64()?);
                },
                112 => {
                    self.number_of_constants = ::std::option::Option::Some(is.read_uint64()?);
                },
                120 => {
                    self.number_of_field_offsets = ::std::option::Option::Some(is.read_uint64()?);
                },
                130 => {
                    self.typelib = ::std::option::Option::Some(is.read_string()?);
                },
                138 => {
                    self.streams.push(is.read_message()?);
                },
                146 => {
                    self.guids.push(is.read_string()?);
                },
                154 => {
                    self.constants.push(is.read_bytes()?);
                },
                162 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.assembly)?;
                },
                170 => {
                    self.assembly_refs.push(is.read_message()?);
                },
                178 => {
                    self.resources.push(is.read_message()?);
                },
                186 => {
                    self.classes.push(is.read_message()?);
                },
                194 => {
                    is.read_repeated_packed_uint32_into(&mut self.field_offsets)?;
                },
                192 => {
                    self.field_offsets.push(is.read_uint32()?);
                },
                202 => {
                    self.user_strings.push(is.read_bytes()?);
                },
                210 => {
                    self.modulerefs.push(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.is_dotnet {
            my_size += 1 + 1;
        }
        if let Some(v) = self.module_name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.version.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.number_of_streams {
            my_size += ::protobuf::rt::uint64_size(4, v);
        }
        if let Some(v) = self.number_of_guids {
            my_size += ::protobuf::rt::uint64_size(5, v);
        }
        if let Some(v) = self.number_of_resources {
            my_size += ::protobuf::rt::uint64_size(6, v);
        }
        if let Some(v) = self.number_of_generic_parameters {
            my_size += ::protobuf::rt::uint64_size(7, v);
        }
        if let Some(v) = self.number_of_classes {
            my_size += ::protobuf::rt::uint64_size(10, v);
        }
        if let Some(v) = self.number_of_assembly_refs {
            my_size += ::protobuf::rt::uint64_size(11, v);
        }
        if let Some(v) = self.number_of_modulerefs {
            my_size += ::protobuf::rt::uint64_size(12, v);
        }
        if let Some(v) = self.number_of_user_strings {
            my_size += ::protobuf::rt::uint64_size(13, v);
        }
        if let Some(v) = self.number_of_constants {
            my_size += ::protobuf::rt::uint64_size(14, v);
        }
        if let Some(v) = self.number_of_field_offsets {
            my_size += ::protobuf::rt::uint64_size(15, v);
        }
        if let Some(v) = self.typelib.as_ref() {
            my_size += ::protobuf::rt::string_size(16, &v);
        }
        for value in &self.streams {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.guids {
            my_size += ::protobuf::rt::string_size(18, &value);
        };
        for value in &self.constants {
            my_size += ::protobuf::rt::bytes_size(19, &value);
        };
        if let Some(v) = self.assembly.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.assembly_refs {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.resources {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.classes {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.field_offsets {
            my_size += ::protobuf::rt::uint32_size(24, *value);
        };
        for value in &self.user_strings {
            my_size += ::protobuf::rt::bytes_size(25, &value);
        };
        for value in &self.modulerefs {
            my_size += ::protobuf::rt::string_size(26, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.is_dotnet {
            os.write_bool(1, v)?;
        }
        if let Some(v) = self.module_name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.version.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.number_of_streams {
            os.write_uint64(4, v)?;
        }
        if let Some(v) = self.number_of_guids {
            os.write_uint64(5, v)?;
        }
        if let Some(v) = self.number_of_resources {
            os.write_uint64(6, v)?;
        }
        if let Some(v) = self.number_of_generic_parameters {
            os.write_uint64(7, v)?;
        }
        if let Some(v) = self.number_of_classes {
            os.write_uint64(10, v)?;
        }
        if let Some(v) = self.number_of_assembly_refs {
            os.write_uint64(11, v)?;
        }
        if let Some(v) = self.number_of_modulerefs {
            os.write_uint64(12, v)?;
        }
        if let Some(v) = self.number_of_user_strings {
            os.write_uint64(13, v)?;
        }
        if let Some(v) = self.number_of_constants {
            os.write_uint64(14, v)?;
        }
        if let Some(v) = self.number_of_field_offsets {
            os.write_uint64(15, v)?;
        }
        if let Some(v) = self.typelib.as_ref() {
            os.write_string(16, v)?;
        }
        for v in &self.streams {
            ::protobuf::rt::write_message_field_with_cached_size(17, v, os)?;
        };
        for v in &self.guids {
            os.write_string(18, &v)?;
        };
        for v in &self.constants {
            os.write_bytes(19, &v)?;
        };
        if let Some(v) = self.assembly.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
        }
        for v in &self.assembly_refs {
            ::protobuf::rt::write_message_field_with_cached_size(21, v, os)?;
        };
        for v in &self.resources {
            ::protobuf::rt::write_message_field_with_cached_size(22, v, os)?;
        };
        for v in &self.classes {
            ::protobuf::rt::write_message_field_with_cached_size(23, v, os)?;
        };
        for v in &self.field_offsets {
            os.write_uint32(24, *v)?;
        };
        for v in &self.user_strings {
            os.write_bytes(25, &v)?;
        };
        for v in &self.modulerefs {
            os.write_string(26, &v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Dotnet {
        Dotnet::new()
    }

    fn clear(&mut self) {
        self.is_dotnet = ::std::option::Option::None;
        self.module_name = ::std::option::Option::None;
        self.version = ::std::option::Option::None;
        self.number_of_streams = ::std::option::Option::None;
        self.number_of_guids = ::std::option::Option::None;
        self.number_of_resources = ::std::option::Option::None;
        self.number_of_generic_parameters = ::std::option::Option::None;
        self.number_of_classes = ::std::option::Option::None;
        self.number_of_assembly_refs = ::std::option::Option::None;
        self.number_of_modulerefs = ::std::option::Option::None;
        self.number_of_user_strings = ::std::option::Option::None;
        self.number_of_constants = ::std::option::Option::None;
        self.number_of_field_offsets = ::std::option::Option::None;
        self.typelib = ::std::option::Option::None;
        self.streams.clear();
        self.guids.clear();
        self.constants.clear();
        self.assembly.clear();
        self.assembly_refs.clear();
        self.resources.clear();
        self.classes.clear();
        self.field_offsets.clear();
        self.user_strings.clear();
        self.modulerefs.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Dotnet {
        static instance: Dotnet = Dotnet {
            is_dotnet: ::std::option::Option::None,
            module_name: ::std::option::Option::None,
            version: ::std::option::Option::None,
            number_of_streams: ::std::option::Option::None,
            number_of_guids: ::std::option::Option::None,
            number_of_resources: ::std::option::Option::None,
            number_of_generic_parameters: ::std::option::Option::None,
            number_of_classes: ::std::option::Option::None,
            number_of_assembly_refs: ::std::option::Option::None,
            number_of_modulerefs: ::std::option::Option::None,
            number_of_user_strings: ::std::option::Option::None,
            number_of_constants: ::std::option::Option::None,
            number_of_field_offsets: ::std::option::Option::None,
            typelib: ::std::option::Option::None,
            streams: ::std::vec::Vec::new(),
            guids: ::std::vec::Vec::new(),
            constants: ::std::vec::Vec::new(),
            assembly: ::protobuf::MessageField::none(),
            assembly_refs: ::std::vec::Vec::new(),
            resources: ::std::vec::Vec::new(),
            classes: ::std::vec::Vec::new(),
            field_offsets: ::std::vec::Vec::new(),
            user_strings: ::std::vec::Vec::new(),
            modulerefs: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Dotnet {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Dotnet").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Dotnet {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Dotnet {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Assembly)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Assembly {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Assembly.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Assembly.culture)
    pub culture: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Assembly.version)
    pub version: ::protobuf::MessageField<Version>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Assembly.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Assembly {
    fn default() -> &'a Assembly {
        <Assembly as ::protobuf::Message>::default_instance()
    }
}

impl Assembly {
    pub fn new() -> Assembly {
        ::std::default::Default::default()
    }

    // optional string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string culture = 2;

    pub fn culture(&self) -> &str {
        match self.culture.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_culture(&mut self) {
        self.culture = ::std::option::Option::None;
    }

    pub fn has_culture(&self) -> bool {
        self.culture.is_some()
    }

    // Param is passed by value, moved
    pub fn set_culture(&mut self, v: ::std::string::String) {
        self.culture = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_culture(&mut self) -> &mut ::std::string::String {
        if self.culture.is_none() {
            self.culture = ::std::option::Option::Some(::std::string::String::new());
        }
        self.culture.as_mut().unwrap()
    }

    // Take field
    pub fn take_culture(&mut self) -> ::std::string::String {
        self.culture.take().unwrap_or_else(|| ::std::string::String::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Assembly| { &m.name },
            |m: &mut Assembly| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "culture",
            |m: &Assembly| { &m.culture },
            |m: &mut Assembly| { &mut m.culture },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Version>(
            "version",
            |m: &Assembly| { &m.version },
            |m: &mut Assembly| { &mut m.version },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Assembly>(
            "Assembly",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Assembly {
    const NAME: &'static str = "Assembly";

    fn is_initialized(&self) -> bool {
        if self.version.is_none() {
            return false;
        }
        for v in &self.version {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.culture = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.version)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.culture.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.version.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.culture.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.version.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Assembly {
        Assembly::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.culture = ::std::option::Option::None;
        self.version.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Assembly {
        static instance: Assembly = Assembly {
            name: ::std::option::Option::None,
            culture: ::std::option::Option::None,
            version: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Assembly {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Assembly").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Assembly {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Assembly {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.AssemblyRef)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct AssemblyRef {
    // message fields
    // @@protoc_insertion_point(field:dotnet.AssemblyRef.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.AssemblyRef.public_key_or_token)
    pub public_key_or_token: ::std::option::Option<::std::vec::Vec<u8>>,
    // @@protoc_insertion_point(field:dotnet.AssemblyRef.version)
    pub version: ::protobuf::MessageField<Version>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.AssemblyRef.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a AssemblyRef {
    fn default() -> &'a AssemblyRef {
        <AssemblyRef as ::protobuf::Message>::default_instance()
    }
}

impl AssemblyRef {
    pub fn new() -> AssemblyRef {
        ::std::default::Default::default()
    }

    // optional string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional bytes public_key_or_token = 2;

    pub fn public_key_or_token(&self) -> &[u8] {
        match self.public_key_or_token.as_ref() {
            Some(v) => v,
            None => &[],
        }
    }

    pub fn clear_public_key_or_token(&mut self) {
        self.public_key_or_token = ::std::option::Option::None;
    }

    pub fn has_public_key_or_token(&self) -> bool {
        self.public_key_or_token.is_some()
    }

    // Param is passed by value, moved
    pub fn set_public_key_or_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.public_key_or_token = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_public_key_or_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        if self.public_key_or_token.is_none() {
            self.public_key_or_token = ::std::option::Option::Some(::std::vec::Vec::new());
        }
        self.public_key_or_token.as_mut().unwrap()
    }

    // Take field
    pub fn take_public_key_or_token(&mut self) -> ::std::vec::Vec<u8> {
        self.public_key_or_token.take().unwrap_or_else(|| ::std::vec::Vec::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &AssemblyRef| { &m.name },
            |m: &mut AssemblyRef| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "public_key_or_token",
            |m: &AssemblyRef| { &m.public_key_or_token },
            |m: &mut AssemblyRef| { &mut m.public_key_or_token },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Version>(
            "version",
            |m: &AssemblyRef| { &m.version },
            |m: &mut AssemblyRef| { &mut m.version },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AssemblyRef>(
            "AssemblyRef",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for AssemblyRef {
    const NAME: &'static str = "AssemblyRef";

    fn is_initialized(&self) -> bool {
        if self.version.is_none() {
            return false;
        }
        for v in &self.version {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.public_key_or_token = ::std::option::Option::Some(is.read_bytes()?);
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.version)?;
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.public_key_or_token.as_ref() {
            my_size += ::protobuf::rt::bytes_size(2, &v);
        }
        if let Some(v) = self.version.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.public_key_or_token.as_ref() {
            os.write_bytes(2, v)?;
        }
        if let Some(v) = self.version.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> AssemblyRef {
        AssemblyRef::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.public_key_or_token = ::std::option::Option::None;
        self.version.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static AssemblyRef {
        static instance: AssemblyRef = AssemblyRef {
            name: ::std::option::Option::None,
            public_key_or_token: ::std::option::Option::None,
            version: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for AssemblyRef {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("AssemblyRef").unwrap()).clone()
    }
}

impl ::std::fmt::Display for AssemblyRef {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for AssemblyRef {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Stream)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Stream {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Stream.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Stream.offset)
    pub offset: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Stream.size)
    pub size: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Stream.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Stream {
    fn default() -> &'a Stream {
        <Stream as ::protobuf::Message>::default_instance()
    }
}

impl Stream {
    pub fn new() -> Stream {
        ::std::default::Default::default()
    }

    // optional string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required uint32 offset = 2;

    pub fn offset(&self) -> u32 {
        self.offset.unwrap_or(0)
    }

    pub fn clear_offset(&mut self) {
        self.offset = ::std::option::Option::None;
    }

    pub fn has_offset(&self) -> bool {
        self.offset.is_some()
    }

    // Param is passed by value, moved
    pub fn set_offset(&mut self, v: u32) {
        self.offset = ::std::option::Option::Some(v);
    }

    // required uint32 size = 3;

    pub fn size(&self) -> u32 {
        self.size.unwrap_or(0)
    }

    pub fn clear_size(&mut self) {
        self.size = ::std::option::Option::None;
    }

    pub fn has_size(&self) -> bool {
        self.size.is_some()
    }

    // Param is passed by value, moved
    pub fn set_size(&mut self, v: u32) {
        self.size = ::std::option::Option::Some(v);
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Stream| { &m.name },
            |m: &mut Stream| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "offset",
            |m: &Stream| { &m.offset },
            |m: &mut Stream| { &mut m.offset },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "size",
            |m: &Stream| { &m.size },
            |m: &mut Stream| { &mut m.size },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Stream>(
            "Stream",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Stream {
    const NAME: &'static str = "Stream";

    fn is_initialized(&self) -> bool {
        if self.offset.is_none() {
            return false;
        }
        if self.size.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                16 => {
                    self.offset = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.size = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.offset {
            my_size += ::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.size {
            my_size += ::protobuf::rt::uint32_size(3, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.offset {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.size {
            os.write_uint32(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Stream {
        Stream::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.offset = ::std::option::Option::None;
        self.size = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Stream {
        static instance: Stream = Stream {
            name: ::std::option::Option::None,
            offset: ::std::option::Option::None,
            size: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Stream {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Stream").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Stream {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Stream {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Version)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Version {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Version.major)
    pub major: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Version.minor)
    pub minor: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Version.build_number)
    pub build_number: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Version.revision_number)
    pub revision_number: ::std::option::Option<u32>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Version.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Version {
    fn default() -> &'a Version {
        <Version as ::protobuf::Message>::default_instance()
    }
}

impl Version {
    pub fn new() -> Version {
        ::std::default::Default::default()
    }

    // required uint32 major = 1;

    pub fn major(&self) -> u32 {
        self.major.unwrap_or(0)
    }

    pub fn clear_major(&mut self) {
        self.major = ::std::option::Option::None;
    }

    pub fn has_major(&self) -> bool {
        self.major.is_some()
    }

    // Param is passed by value, moved
    pub fn set_major(&mut self, v: u32) {
        self.major = ::std::option::Option::Some(v);
    }

    // required uint32 minor = 2;

    pub fn minor(&self) -> u32 {
        self.minor.unwrap_or(0)
    }

    pub fn clear_minor(&mut self) {
        self.minor = ::std::option::Option::None;
    }

    pub fn has_minor(&self) -> bool {
        self.minor.is_some()
    }

    // Param is passed by value, moved
    pub fn set_minor(&mut self, v: u32) {
        self.minor = ::std::option::Option::Some(v);
    }

    // required uint32 build_number = 3;

    pub fn build_number(&self) -> u32 {
        self.build_number.unwrap_or(0)
    }

    pub fn clear_build_number(&mut self) {
        self.build_number = ::std::option::Option::None;
    }

    pub fn has_build_number(&self) -> bool {
        self.build_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_build_number(&mut self, v: u32) {
        self.build_number = ::std::option::Option::Some(v);
    }

    // required uint32 revision_number = 4;

    pub fn revision_number(&self) -> u32 {
        self.revision_number.unwrap_or(0)
    }

    pub fn clear_revision_number(&mut self) {
        self.revision_number = ::std::option::Option::None;
    }

    pub fn has_revision_number(&self) -> bool {
        self.revision_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_revision_number(&mut self, v: u32) {
        self.revision_number = ::std::option::Option::Some(v);
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(4);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "major",
            |m: &Version| { &m.major },
            |m: &mut Version| { &mut m.major },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "minor",
            |m: &Version| { &m.minor },
            |m: &mut Version| { &mut m.minor },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "build_number",
            |m: &Version| { &m.build_number },
            |m: &mut Version| { &mut m.build_number },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "revision_number",
            |m: &Version| { &m.revision_number },
            |m: &mut Version| { &mut m.revision_number },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Version>(
            "Version",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Version {
    const NAME: &'static str = "Version";

    fn is_initialized(&self) -> bool {
        if self.major.is_none() {
            return false;
        }
        if self.minor.is_none() {
            return false;
        }
        if self.build_number.is_none() {
            return false;
        }
        if self.revision_number.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.major = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.minor = ::std::option::Option::Some(is.read_uint32()?);
                },
                24 => {
                    self.build_number = ::std::option::Option::Some(is.read_uint32()?);
                },
                32 => {
                    self.revision_number = ::std::option::Option::Some(is.read_uint32()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.major {
            my_size += ::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.minor {
            my_size += ::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.build_number {
            my_size += ::protobuf::rt::uint32_size(3, v);
        }
        if let Some(v) = self.revision_number {
            my_size += ::protobuf::rt::uint32_size(4, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.major {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.minor {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.build_number {
            os.write_uint32(3, v)?;
        }
        if let Some(v) = self.revision_number {
            os.write_uint32(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Version {
        Version::new()
    }

    fn clear(&mut self) {
        self.major = ::std::option::Option::None;
        self.minor = ::std::option::Option::None;
        self.build_number = ::std::option::Option::None;
        self.revision_number = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Version {
        static instance: Version = Version {
            major: ::std::option::Option::None,
            minor: ::std::option::Option::None,
            build_number: ::std::option::Option::None,
            revision_number: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Version {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Version").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Version {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Version {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Resource)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Resource {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Resource.offset)
    pub offset: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Resource.length)
    pub length: ::std::option::Option<u32>,
    // @@protoc_insertion_point(field:dotnet.Resource.name)
    pub name: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Resource.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Resource {
    fn default() -> &'a Resource {
        <Resource as ::protobuf::Message>::default_instance()
    }
}

impl Resource {
    pub fn new() -> Resource {
        ::std::default::Default::default()
    }

    // optional uint32 offset = 1;

    pub fn offset(&self) -> u32 {
        self.offset.unwrap_or(0)
    }

    pub fn clear_offset(&mut self) {
        self.offset = ::std::option::Option::None;
    }

    pub fn has_offset(&self) -> bool {
        self.offset.is_some()
    }

    // Param is passed by value, moved
    pub fn set_offset(&mut self, v: u32) {
        self.offset = ::std::option::Option::Some(v);
    }

    // optional uint32 length = 2;

    pub fn length(&self) -> u32 {
        self.length.unwrap_or(0)
    }

    pub fn clear_length(&mut self) {
        self.length = ::std::option::Option::None;
    }

    pub fn has_length(&self) -> bool {
        self.length.is_some()
    }

    // Param is passed by value, moved
    pub fn set_length(&mut self, v: u32) {
        self.length = ::std::option::Option::Some(v);
    }

    // optional string name = 3;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(3);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "offset",
            |m: &Resource| { &m.offset },
            |m: &mut Resource| { &mut m.offset },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "length",
            |m: &Resource| { &m.length },
            |m: &mut Resource| { &mut m.length },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Resource| { &m.name },
            |m: &mut Resource| { &mut m.name },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Resource>(
            "Resource",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Resource {
    const NAME: &'static str = "Resource";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.offset = ::std::option::Option::Some(is.read_uint32()?);
                },
                16 => {
                    self.length = ::std::option::Option::Some(is.read_uint32()?);
                },
                26 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.offset {
            my_size += ::protobuf::rt::uint32_size(1, v);
        }
        if let Some(v) = self.length {
            my_size += ::protobuf::rt::uint32_size(2, v);
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.offset {
            os.write_uint32(1, v)?;
        }
        if let Some(v) = self.length {
            os.write_uint32(2, v)?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(3, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Resource {
        Resource::new()
    }

    fn clear(&mut self) {
        self.offset = ::std::option::Option::None;
        self.length = ::std::option::Option::None;
        self.name = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Resource {
        static instance: Resource = Resource {
            offset: ::std::option::Option::None,
            length: ::std::option::Option::None,
            name: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Resource {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Resource").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Resource {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Resource {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Class)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Class {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Class.fullname)
    pub fullname: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.namespace)
    pub namespace: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.visibility)
    pub visibility: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.type)
    pub type_: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.abstract)
    pub abstract_: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Class.sealed)
    pub sealed: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Class.number_of_base_types)
    pub number_of_base_types: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Class.number_of_generic_parameters)
    pub number_of_generic_parameters: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Class.number_of_methods)
    pub number_of_methods: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Class.base_types)
    pub base_types: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.generic_parameters)
    pub generic_parameters: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Class.methods)
    pub methods: ::std::vec::Vec<Method>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Class.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Class {
    fn default() -> &'a Class {
        <Class as ::protobuf::Message>::default_instance()
    }
}

impl Class {
    pub fn new() -> Class {
        ::std::default::Default::default()
    }

    // optional string fullname = 1;

    pub fn fullname(&self) -> &str {
        match self.fullname.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_fullname(&mut self) {
        self.fullname = ::std::option::Option::None;
    }

    pub fn has_fullname(&self) -> bool {
        self.fullname.is_some()
    }

    // Param is passed by value, moved
    pub fn set_fullname(&mut self, v: ::std::string::String) {
        self.fullname = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_fullname(&mut self) -> &mut ::std::string::String {
        if self.fullname.is_none() {
            self.fullname = ::std::option::Option::Some(::std::string::String::new());
        }
        self.fullname.as_mut().unwrap()
    }

    // Take field
    pub fn take_fullname(&mut self) -> ::std::string::String {
        self.fullname.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string name = 2;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string namespace = 3;

    pub fn namespace(&self) -> &str {
        match self.namespace.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_namespace(&mut self) {
        self.namespace = ::std::option::Option::None;
    }

    pub fn has_namespace(&self) -> bool {
        self.namespace.is_some()
    }

    // Param is passed by value, moved
    pub fn set_namespace(&mut self, v: ::std::string::String) {
        self.namespace = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_namespace(&mut self) -> &mut ::std::string::String {
        if self.namespace.is_none() {
            self.namespace = ::std::option::Option::Some(::std::string::String::new());
        }
        self.namespace.as_mut().unwrap()
    }

    // Take field
    pub fn take_namespace(&mut self) -> ::std::string::String {
        self.namespace.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string visibility = 4;

    pub fn visibility(&self) -> &str {
        match self.visibility.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_visibility(&mut self) {
        self.visibility = ::std::option::Option::None;
    }

    pub fn has_visibility(&self) -> bool {
        self.visibility.is_some()
    }

    // Param is passed by value, moved
    pub fn set_visibility(&mut self, v: ::std::string::String) {
        self.visibility = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_visibility(&mut self) -> &mut ::std::string::String {
        if self.visibility.is_none() {
            self.visibility = ::std::option::Option::Some(::std::string::String::new());
        }
        self.visibility.as_mut().unwrap()
    }

    // Take field
    pub fn take_visibility(&mut self) -> ::std::string::String {
        self.visibility.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string type = 5;

    pub fn type_(&self) -> &str {
        match self.type_.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_type_(&mut self) {
        self.type_ = ::std::option::Option::None;
    }

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type(&mut self, v: ::std::string::String) {
        self.type_ = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type(&mut self) -> &mut ::std::string::String {
        if self.type_.is_none() {
            self.type_ = ::std::option::Option::Some(::std::string::String::new());
        }
        self.type_.as_mut().unwrap()
    }

    // Take field
    pub fn take_type_(&mut self) -> ::std::string::String {
        self.type_.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required bool abstract = 6;

    pub fn abstract_(&self) -> bool {
        self.abstract_.unwrap_or(false)
    }

    pub fn clear_abstract_(&mut self) {
        self.abstract_ = ::std::option::Option::None;
    }

    pub fn has_abstract(&self) -> bool {
        self.abstract_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_abstract(&mut self, v: bool) {
        self.abstract_ = ::std::option::Option::Some(v);
    }

    // required bool sealed = 7;

    pub fn sealed(&self) -> bool {
        self.sealed.unwrap_or(false)
    }

    pub fn clear_sealed(&mut self) {
        self.sealed = ::std::option::Option::None;
    }

    pub fn has_sealed(&self) -> bool {
        self.sealed.is_some()
    }

    // Param is passed by value, moved
    pub fn set_sealed(&mut self, v: bool) {
        self.sealed = ::std::option::Option::Some(v);
    }

    // required uint64 number_of_base_types = 8;

    pub fn number_of_base_types(&self) -> u64 {
        self.number_of_base_types.unwrap_or(0)
    }

    pub fn clear_number_of_base_types(&mut self) {
        self.number_of_base_types = ::std::option::Option::None;
    }

    pub fn has_number_of_base_types(&self) -> bool {
        self.number_of_base_types.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_base_types(&mut self, v: u64) {
        self.number_of_base_types = ::std::option::Option::Some(v);
    }

    // required uint64 number_of_generic_parameters = 9;

    pub fn number_of_generic_parameters(&self) -> u64 {
        self.number_of_generic_parameters.unwrap_or(0)
    }

    pub fn clear_number_of_generic_parameters(&mut self) {
        self.number_of_generic_parameters = ::std::option::Option::None;
    }

    pub fn has_number_of_generic_parameters(&self) -> bool {
        self.number_of_generic_parameters.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_generic_parameters(&mut self, v: u64) {
        self.number_of_generic_parameters = ::std::option::Option::Some(v);
    }

    // required uint64 number_of_methods = 10;

    pub fn number_of_methods(&self) -> u64 {
        self.number_of_methods.unwrap_or(0)
    }

    pub fn clear_number_of_methods(&mut self) {
        self.number_of_methods = ::std::option::Option::None;
    }

    pub fn has_number_of_methods(&self) -> bool {
        self.number_of_methods.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_methods(&mut self, v: u64) {
        self.number_of_methods = ::std::option::Option::Some(v);
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(13);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "fullname",
            |m: &Class| { &m.fullname },
            |m: &mut Class| { &mut m.fullname },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Class| { &m.name },
            |m: &mut Class| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "namespace",
            |m: &Class| { &m.namespace },
            |m: &mut Class| { &mut m.namespace },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "visibility",
            |m: &Class| { &m.visibility },
            |m: &mut Class| { &mut m.visibility },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "type",
            |m: &Class| { &m.type_ },
            |m: &mut Class| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "abstract",
            |m: &Class| { &m.abstract_ },
            |m: &mut Class| { &mut m.abstract_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "sealed",
            |m: &Class| { &m.sealed },
            |m: &mut Class| { &mut m.sealed },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_base_types",
            |m: &Class| { &m.number_of_base_types },
            |m: &mut Class| { &mut m.number_of_base_types },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_generic_parameters",
            |m: &Class| { &m.number_of_generic_parameters },
            |m: &mut Class| { &mut m.number_of_generic_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_methods",
            |m: &Class| { &m.number_of_methods },
            |m: &mut Class| { &mut m.number_of_methods },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "base_types",
            |m: &Class| { &m.base_types },
            |m: &mut Class| { &mut m.base_types },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "generic_parameters",
            |m: &Class| { &m.generic_parameters },
            |m: &mut Class| { &mut m.generic_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "methods",
            |m: &Class| { &m.methods },
            |m: &mut Class| { &mut m.methods },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Class>(
            "Class",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Class {
    const NAME: &'static str = "Class";

    fn is_initialized(&self) -> bool {
        if self.abstract_.is_none() {
            return false;
        }
        if self.sealed.is_none() {
            return false;
        }
        if self.number_of_base_types.is_none() {
            return false;
        }
        if self.number_of_generic_parameters.is_none() {
            return false;
        }
        if self.number_of_methods.is_none() {
            return false;
        }
        for v in &self.methods {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.fullname = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                26 => {
                    self.namespace = ::std::option::Option::Some(is.read_string()?);
                },
                34 => {
                    self.visibility = ::std::option::Option::Some(is.read_string()?);
                },
                42 => {
                    self.type_ = ::std::option::Option::Some(is.read_string()?);
                },
                48 => {
                    self.abstract_ = ::std::option::Option::Some(is.read_bool()?);
                },
                56 => {
                    self.sealed = ::std::option::Option::Some(is.read_bool()?);
                },
                64 => {
                    self.number_of_base_types = ::std::option::Option::Some(is.read_uint64()?);
                },
                72 => {
                    self.number_of_generic_parameters = ::std::option::Option::Some(is.read_uint64()?);
                },
                80 => {
                    self.number_of_methods = ::std::option::Option::Some(is.read_uint64()?);
                },
                90 => {
                    self.base_types.push(is.read_string()?);
                },
                98 => {
                    self.generic_parameters.push(is.read_string()?);
                },
                106 => {
                    self.methods.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.fullname.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.namespace.as_ref() {
            my_size += ::protobuf::rt::string_size(3, &v);
        }
        if let Some(v) = self.visibility.as_ref() {
            my_size += ::protobuf::rt::string_size(4, &v);
        }
        if let Some(v) = self.type_.as_ref() {
            my_size += ::protobuf::rt::string_size(5, &v);
        }
        if let Some(v) = self.abstract_ {
            my_size += 1 + 1;
        }
        if let Some(v) = self.sealed {
            my_size += 1 + 1;
        }
        if let Some(v) = self.number_of_base_types {
            my_size += ::protobuf::rt::uint64_size(8, v);
        }
        if let Some(v) = self.number_of_generic_parameters {
            my_size += ::protobuf::rt::uint64_size(9, v);
        }
        if let Some(v) = self.number_of_methods {
            my_size += ::protobuf::rt::uint64_size(10, v);
        }
        for value in &self.base_types {
            my_size += ::protobuf::rt::string_size(11, &value);
        };
        for value in &self.generic_parameters {
            my_size += ::protobuf::rt::string_size(12, &value);
        };
        for value in &self.methods {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.fullname.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.name.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.namespace.as_ref() {
            os.write_string(3, v)?;
        }
        if let Some(v) = self.visibility.as_ref() {
            os.write_string(4, v)?;
        }
        if let Some(v) = self.type_.as_ref() {
            os.write_string(5, v)?;
        }
        if let Some(v) = self.abstract_ {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.sealed {
            os.write_bool(7, v)?;
        }
        if let Some(v) = self.number_of_base_types {
            os.write_uint64(8, v)?;
        }
        if let Some(v) = self.number_of_generic_parameters {
            os.write_uint64(9, v)?;
        }
        if let Some(v) = self.number_of_methods {
            os.write_uint64(10, v)?;
        }
        for v in &self.base_types {
            os.write_string(11, &v)?;
        };
        for v in &self.generic_parameters {
            os.write_string(12, &v)?;
        };
        for v in &self.methods {
            ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Class {
        Class::new()
    }

    fn clear(&mut self) {
        self.fullname = ::std::option::Option::None;
        self.name = ::std::option::Option::None;
        self.namespace = ::std::option::Option::None;
        self.visibility = ::std::option::Option::None;
        self.type_ = ::std::option::Option::None;
        self.abstract_ = ::std::option::Option::None;
        self.sealed = ::std::option::Option::None;
        self.number_of_base_types = ::std::option::Option::None;
        self.number_of_generic_parameters = ::std::option::Option::None;
        self.number_of_methods = ::std::option::Option::None;
        self.base_types.clear();
        self.generic_parameters.clear();
        self.methods.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Class {
        static instance: Class = Class {
            fullname: ::std::option::Option::None,
            name: ::std::option::Option::None,
            namespace: ::std::option::Option::None,
            visibility: ::std::option::Option::None,
            type_: ::std::option::Option::None,
            abstract_: ::std::option::Option::None,
            sealed: ::std::option::Option::None,
            number_of_base_types: ::std::option::Option::None,
            number_of_generic_parameters: ::std::option::Option::None,
            number_of_methods: ::std::option::Option::None,
            base_types: ::std::vec::Vec::new(),
            generic_parameters: ::std::vec::Vec::new(),
            methods: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Class {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Class").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Class {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Class {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Method)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Method {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Method.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Method.visibility)
    pub visibility: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Method.abstract)
    pub abstract_: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Method.static)
    pub static_: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Method.virtual)
    pub virtual_: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Method.final)
    pub final_: ::std::option::Option<bool>,
    // @@protoc_insertion_point(field:dotnet.Method.return_type)
    pub return_type: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Method.number_of_generic_parameters)
    pub number_of_generic_parameters: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Method.number_of_parameters)
    pub number_of_parameters: ::std::option::Option<u64>,
    // @@protoc_insertion_point(field:dotnet.Method.generic_parameters)
    pub generic_parameters: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Method.parameters)
    pub parameters: ::std::vec::Vec<Param>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Method.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Method {
    fn default() -> &'a Method {
        <Method as ::protobuf::Message>::default_instance()
    }
}

impl Method {
    pub fn new() -> Method {
        ::std::default::Default::default()
    }

    // optional string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string visibility = 2;

    pub fn visibility(&self) -> &str {
        match self.visibility.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_visibility(&mut self) {
        self.visibility = ::std::option::Option::None;
    }

    pub fn has_visibility(&self) -> bool {
        self.visibility.is_some()
    }

    // Param is passed by value, moved
    pub fn set_visibility(&mut self, v: ::std::string::String) {
        self.visibility = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_visibility(&mut self) -> &mut ::std::string::String {
        if self.visibility.is_none() {
            self.visibility = ::std::option::Option::Some(::std::string::String::new());
        }
        self.visibility.as_mut().unwrap()
    }

    // Take field
    pub fn take_visibility(&mut self) -> ::std::string::String {
        self.visibility.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required bool abstract = 3;

    pub fn abstract_(&self) -> bool {
        self.abstract_.unwrap_or(false)
    }

    pub fn clear_abstract_(&mut self) {
        self.abstract_ = ::std::option::Option::None;
    }

    pub fn has_abstract(&self) -> bool {
        self.abstract_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_abstract(&mut self, v: bool) {
        self.abstract_ = ::std::option::Option::Some(v);
    }

    // required bool static = 4;

    pub fn static_(&self) -> bool {
        self.static_.unwrap_or(false)
    }

    pub fn clear_static_(&mut self) {
        self.static_ = ::std::option::Option::None;
    }

    pub fn has_static(&self) -> bool {
        self.static_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_static(&mut self, v: bool) {
        self.static_ = ::std::option::Option::Some(v);
    }

    // required bool virtual = 5;

    pub fn virtual_(&self) -> bool {
        self.virtual_.unwrap_or(false)
    }

    pub fn clear_virtual_(&mut self) {
        self.virtual_ = ::std::option::Option::None;
    }

    pub fn has_virtual(&self) -> bool {
        self.virtual_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_virtual(&mut self, v: bool) {
        self.virtual_ = ::std::option::Option::Some(v);
    }

    // required bool final = 6;

    pub fn final_(&self) -> bool {
        self.final_.unwrap_or(false)
    }

    pub fn clear_final_(&mut self) {
        self.final_ = ::std::option::Option::None;
    }

    pub fn has_final(&self) -> bool {
        self.final_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_final(&mut self, v: bool) {
        self.final_ = ::std::option::Option::Some(v);
    }

    // optional string return_type = 7;

    pub fn return_type(&self) -> &str {
        match self.return_type.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_return_type(&mut self) {
        self.return_type = ::std::option::Option::None;
    }

    pub fn has_return_type(&self) -> bool {
        self.return_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_return_type(&mut self, v: ::std::string::String) {
        self.return_type = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_return_type(&mut self) -> &mut ::std::string::String {
        if self.return_type.is_none() {
            self.return_type = ::std::option::Option::Some(::std::string::String::new());
        }
        self.return_type.as_mut().unwrap()
    }

    // Take field
    pub fn take_return_type(&mut self) -> ::std::string::String {
        self.return_type.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // required uint64 number_of_generic_parameters = 8;

    pub fn number_of_generic_parameters(&self) -> u64 {
        self.number_of_generic_parameters.unwrap_or(0)
    }

    pub fn clear_number_of_generic_parameters(&mut self) {
        self.number_of_generic_parameters = ::std::option::Option::None;
    }

    pub fn has_number_of_generic_parameters(&self) -> bool {
        self.number_of_generic_parameters.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_generic_parameters(&mut self, v: u64) {
        self.number_of_generic_parameters = ::std::option::Option::Some(v);
    }

    // required uint64 number_of_parameters = 9;

    pub fn number_of_parameters(&self) -> u64 {
        self.number_of_parameters.unwrap_or(0)
    }

    pub fn clear_number_of_parameters(&mut self) {
        self.number_of_parameters = ::std::option::Option::None;
    }

    pub fn has_number_of_parameters(&self) -> bool {
        self.number_of_parameters.is_some()
    }

    // Param is passed by value, moved
    pub fn set_number_of_parameters(&mut self, v: u64) {
        self.number_of_parameters = ::std::option::Option::Some(v);
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(11);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Method| { &m.name },
            |m: &mut Method| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "visibility",
            |m: &Method| { &m.visibility },
            |m: &mut Method| { &mut m.visibility },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "abstract",
            |m: &Method| { &m.abstract_ },
            |m: &mut Method| { &mut m.abstract_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "static",
            |m: &Method| { &m.static_ },
            |m: &mut Method| { &mut m.static_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "virtual",
            |m: &Method| { &m.virtual_ },
            |m: &mut Method| { &mut m.virtual_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "final",
            |m: &Method| { &m.final_ },
            |m: &mut Method| { &mut m.final_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "return_type",
            |m: &Method| { &m.return_type },
            |m: &mut Method| { &mut m.return_type },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_generic_parameters",
            |m: &Method| { &m.number_of_generic_parameters },
            |m: &mut Method| { &mut m.number_of_generic_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "number_of_parameters",
            |m: &Method| { &m.number_of_parameters },
            |m: &mut Method| { &mut m.number_of_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "generic_parameters",
            |m: &Method| { &m.generic_parameters },
            |m: &mut Method| { &mut m.generic_parameters },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "parameters",
            |m: &Method| { &m.parameters },
            |m: &mut Method| { &mut m.parameters },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Method>(
            "Method",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Method {
    const NAME: &'static str = "Method";

    fn is_initialized(&self) -> bool {
        if self.abstract_.is_none() {
            return false;
        }
        if self.static_.is_none() {
            return false;
        }
        if self.virtual_.is_none() {
            return false;
        }
        if self.final_.is_none() {
            return false;
        }
        if self.number_of_generic_parameters.is_none() {
            return false;
        }
        if self.number_of_parameters.is_none() {
            return false;
        }
        for v in &self.parameters {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.visibility = ::std::option::Option::Some(is.read_string()?);
                },
                24 => {
                    self.abstract_ = ::std::option::Option::Some(is.read_bool()?);
                },
                32 => {
                    self.static_ = ::std::option::Option::Some(is.read_bool()?);
                },
                40 => {
                    self.virtual_ = ::std::option::Option::Some(is.read_bool()?);
                },
                48 => {
                    self.final_ = ::std::option::Option::Some(is.read_bool()?);
                },
                58 => {
                    self.return_type = ::std::option::Option::Some(is.read_string()?);
                },
                64 => {
                    self.number_of_generic_parameters = ::std::option::Option::Some(is.read_uint64()?);
                },
                72 => {
                    self.number_of_parameters = ::std::option::Option::Some(is.read_uint64()?);
                },
                82 => {
                    self.generic_parameters.push(is.read_string()?);
                },
                90 => {
                    self.parameters.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.visibility.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        if let Some(v) = self.abstract_ {
            my_size += 1 + 1;
        }
        if let Some(v) = self.static_ {
            my_size += 1 + 1;
        }
        if let Some(v) = self.virtual_ {
            my_size += 1 + 1;
        }
        if let Some(v) = self.final_ {
            my_size += 1 + 1;
        }
        if let Some(v) = self.return_type.as_ref() {
            my_size += ::protobuf::rt::string_size(7, &v);
        }
        if let Some(v) = self.number_of_generic_parameters {
            my_size += ::protobuf::rt::uint64_size(8, v);
        }
        if let Some(v) = self.number_of_parameters {
            my_size += ::protobuf::rt::uint64_size(9, v);
        }
        for value in &self.generic_parameters {
            my_size += ::protobuf::rt::string_size(10, &value);
        };
        for value in &self.parameters {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.visibility.as_ref() {
            os.write_string(2, v)?;
        }
        if let Some(v) = self.abstract_ {
            os.write_bool(3, v)?;
        }
        if let Some(v) = self.static_ {
            os.write_bool(4, v)?;
        }
        if let Some(v) = self.virtual_ {
            os.write_bool(5, v)?;
        }
        if let Some(v) = self.final_ {
            os.write_bool(6, v)?;
        }
        if let Some(v) = self.return_type.as_ref() {
            os.write_string(7, v)?;
        }
        if let Some(v) = self.number_of_generic_parameters {
            os.write_uint64(8, v)?;
        }
        if let Some(v) = self.number_of_parameters {
            os.write_uint64(9, v)?;
        }
        for v in &self.generic_parameters {
            os.write_string(10, &v)?;
        };
        for v in &self.parameters {
            ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Method {
        Method::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.visibility = ::std::option::Option::None;
        self.abstract_ = ::std::option::Option::None;
        self.static_ = ::std::option::Option::None;
        self.virtual_ = ::std::option::Option::None;
        self.final_ = ::std::option::Option::None;
        self.return_type = ::std::option::Option::None;
        self.number_of_generic_parameters = ::std::option::Option::None;
        self.number_of_parameters = ::std::option::Option::None;
        self.generic_parameters.clear();
        self.parameters.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Method {
        static instance: Method = Method {
            name: ::std::option::Option::None,
            visibility: ::std::option::Option::None,
            abstract_: ::std::option::Option::None,
            static_: ::std::option::Option::None,
            virtual_: ::std::option::Option::None,
            final_: ::std::option::Option::None,
            return_type: ::std::option::Option::None,
            number_of_generic_parameters: ::std::option::Option::None,
            number_of_parameters: ::std::option::Option::None,
            generic_parameters: ::std::vec::Vec::new(),
            parameters: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Method {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Method").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Method {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Method {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

// @@protoc_insertion_point(message:dotnet.Param)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Param {
    // message fields
    // @@protoc_insertion_point(field:dotnet.Param.name)
    pub name: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:dotnet.Param.type)
    pub type_: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:dotnet.Param.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Param {
    fn default() -> &'a Param {
        <Param as ::protobuf::Message>::default_instance()
    }
}

impl Param {
    pub fn new() -> Param {
        ::std::default::Default::default()
    }

    // required string name = 1;

    pub fn name(&self) -> &str {
        match self.name.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_name(&mut self) {
        self.name = ::std::option::Option::None;
    }

    pub fn has_name(&self) -> bool {
        self.name.is_some()
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        if self.name.is_none() {
            self.name = ::std::option::Option::Some(::std::string::String::new());
        }
        self.name.as_mut().unwrap()
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        self.name.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string type = 2;

    pub fn type_(&self) -> &str {
        match self.type_.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_type_(&mut self) {
        self.type_ = ::std::option::Option::None;
    }

    pub fn has_type(&self) -> bool {
        self.type_.is_some()
    }

    // Param is passed by value, moved
    pub fn set_type(&mut self, v: ::std::string::String) {
        self.type_ = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_type(&mut self) -> &mut ::std::string::String {
        if self.type_.is_none() {
            self.type_ = ::std::option::Option::Some(::std::string::String::new());
        }
        self.type_.as_mut().unwrap()
    }

    // Take field
    pub fn take_type_(&mut self) -> ::std::string::String {
        self.type_.take().unwrap_or_else(|| ::std::string::String::new())
    }

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(2);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "name",
            |m: &Param| { &m.name },
            |m: &mut Param| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
            "type",
            |m: &Param| { &m.type_ },
            |m: &mut Param| { &mut m.type_ },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Param>(
            "Param",
            fields,
            oneofs,
        )
    }
}

impl ::protobuf::Message for Param {
    const NAME: &'static str = "Param";

    fn is_initialized(&self) -> bool {
        if self.name.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.name = ::std::option::Option::Some(is.read_string()?);
                },
                18 => {
                    self.type_ = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.name.as_ref() {
            my_size += ::protobuf::rt::string_size(1, &v);
        }
        if let Some(v) = self.type_.as_ref() {
            my_size += ::protobuf::rt::string_size(2, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.name.as_ref() {
            os.write_string(1, v)?;
        }
        if let Some(v) = self.type_.as_ref() {
            os.write_string(2, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Param {
        Param::new()
    }

    fn clear(&mut self) {
        self.name = ::std::option::Option::None;
        self.type_ = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Param {
        static instance: Param = Param {
            name: ::std::option::Option::None,
            type_: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Param {
    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
        descriptor.get(|| file_descriptor().message_by_package_relative_name("Param").unwrap()).clone()
    }
}

impl ::std::fmt::Display for Param {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Param {
    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0cdotnet.proto\x12\x06dotnet\x1a\nyara.proto\"\xa6\x0e\n\x06Dotnet\
    \x12\x1b\n\tis_dotnet\x18\x01\x20\x01(\x08R\x08isDotnet\x12\x1f\n\x0bmod\
    ule_name\x18\x02\x20\x01(\tR\nmoduleName\x12\x18\n\x07version\x18\x03\
    \x20\x01(\tR\x07version\x12\x7f\n\x11number_of_streams\x18\x04\x20\x01(\
    \x04R\x0fnumberOfStreamsBS\x82\x93\x19O2M\n\x18this\x20field\x20is\x20de\
    precated\x12\"use\x20`dotnet.streams.len()`\x20instead\x1a\rstreams.len(\
    )\x12w\n\x0fnumber_of_guids\x18\x05\x20\x01(\x04R\rnumberOfGuidsBO\x82\
    \x93\x19K2I\n\x18this\x20field\x20is\x20deprecated\x12\x20use\x20`dotnet\
    .guids.len()`\x20instead\x1a\x0bguids.len()\x12\x87\x01\n\x13number_of_r\
    esources\x18\x06\x20\x01(\x04R\x11numberOfResourcesBW\x82\x93\x19S2Q\n\
    \x18this\x20field\x20is\x20deprecated\x12$use\x20`dotnet.resources.len()\
    `\x20instead\x1a\x0fresources.len()\x12?\n\x1cnumber_of_generic_paramete\
    rs\x18\x07\x20\x01(\x04R\x19numberOfGenericParameters\x12\x7f\n\x11numbe\
    r_of_classes\x18\n\x20\x01(\x04R\x0fnumberOfClassesBS\x82\x93\x19O2M\n\
    \x18this\x20field\x20is\x20deprecated\x12\"use\x20`dotnet.classes.len()`\
    \x20instead\x1a\rclasses.len()\x12\x96\x01\n\x17number_of_assembly_refs\
    \x18\x0b\x20\x01(\x04R\x14numberOfAssemblyRefsB_\x82\x93\x19[2Y\n\x18thi\
    s\x20field\x20is\x20deprecated\x12(use\x20`dotnet.assembly_refs.len()`\
    \x20instead\x1a\x13assembly_refs.len()\x12\x8b\x01\n\x14number_of_module\
    refs\x18\x0c\x20\x01(\x04R\x12numberOfModulerefsBY\x82\x93\x19U2S\n\x18t\
    his\x20field\x20is\x20deprecated\x12%use\x20`dotnet.modulerefs.len()`\
    \x20instead\x1a\x10modulerefs.len()\x12\x92\x01\n\x16number_of_user_stri\
    ngs\x18\r\x20\x01(\x04R\x13numberOfUserStringsB]\x82\x93\x19Y2W\n\x18thi\
    s\x20field\x20is\x20deprecated\x12'use\x20`dotnet.user_strings.len()`\
    \x20instead\x1a\x12user_strings.len()\x12\x87\x01\n\x13number_of_constan\
    ts\x18\x0e\x20\x01(\x04R\x11numberOfConstantsBW\x82\x93\x19S2Q\n\x18this\
    \x20field\x20is\x20deprecated\x12$use\x20`dotnet.constants.len()`\x20ins\
    tead\x1a\x0fconstants.len()\x12\x96\x01\n\x17number_of_field_offsets\x18\
    \x0f\x20\x01(\x04R\x14numberOfFieldOffsetsB_\x82\x93\x19[2Y\n\x18this\
    \x20field\x20is\x20deprecated\x12(use\x20`dotnet.field_offsets.len()`\
    \x20instead\x1a\x13field_offsets.len()\x12\x18\n\x07typelib\x18\x10\x20\
    \x01(\tR\x07typelib\x12(\n\x07streams\x18\x11\x20\x03(\x0b2\x0e.dotnet.S\
    treamR\x07streams\x12\x14\n\x05guids\x18\x12\x20\x03(\tR\x05guids\x12\
    \x1c\n\tconstants\x18\x13\x20\x03(\x0cR\tconstants\x12,\n\x08assembly\
    \x18\x14\x20\x01(\x0b2\x10.dotnet.AssemblyR\x08assembly\x128\n\rassembly\
    _refs\x18\x15\x20\x03(\x0b2\x13.dotnet.AssemblyRefR\x0cassemblyRefs\x12.\
    \n\tresources\x18\x16\x20\x03(\x0b2\x10.dotnet.ResourceR\tresources\x12'\
    \n\x07classes\x18\x17\x20\x03(\x0b2\r.dotnet.ClassR\x07classes\x12#\n\rf\
    ield_offsets\x18\x18\x20\x03(\rR\x0cfieldOffsets\x12!\n\x0cuser_strings\
    \x18\x19\x20\x03(\x0cR\x0buserStrings\x12\x1e\n\nmodulerefs\x18\x1a\x20\
    \x03(\tR\nmodulerefs\"c\n\x08Assembly\x12\x12\n\x04name\x18\x01\x20\x01(\
    \tR\x04name\x12\x18\n\x07culture\x18\x02\x20\x01(\tR\x07culture\x12)\n\
    \x07version\x18\x03\x20\x02(\x0b2\x0f.dotnet.VersionR\x07version\"{\n\
    \x0bAssemblyRef\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12-\n\x13\
    public_key_or_token\x18\x02\x20\x01(\x0cR\x10publicKeyOrToken\x12)\n\x07\
    version\x18\x03\x20\x02(\x0b2\x0f.dotnet.VersionR\x07version\"Z\n\x06Str\
    eam\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x1f\n\x06offset\
    \x18\x02\x20\x02(\rR\x06offsetB\x07\x82\x93\x19\x03*\x01x\x12\x1b\n\x04s\
    ize\x18\x03\x20\x02(\rR\x04sizeB\x07\x82\x93\x19\x03*\x01x\"\x81\x01\n\
    \x07Version\x12\x14\n\x05major\x18\x01\x20\x02(\rR\x05major\x12\x14\n\
    \x05minor\x18\x02\x20\x02(\rR\x05minor\x12!\n\x0cbuild_number\x18\x03\
    \x20\x02(\rR\x0bbuildNumber\x12'\n\x0frevision_number\x18\x04\x20\x02(\r\
    R\x0erevisionNumber\"`\n\x08Resource\x12\x1f\n\x06offset\x18\x01\x20\x01\
    (\rR\x06offsetB\x07\x82\x93\x19\x03*\x01x\x12\x1f\n\x06length\x18\x02\
    \x20\x01(\rR\x06lengthB\x07\x82\x93\x19\x03*\x01x\x12\x12\n\x04name\x18\
    \x03\x20\x01(\tR\x04name\"\xdb\x05\n\x05Class\x12\x1a\n\x08fullname\x18\
    \x01\x20\x01(\tR\x08fullname\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04na\
    me\x12\x1c\n\tnamespace\x18\x03\x20\x01(\tR\tnamespace\x12\x1e\n\nvisibi\
    lity\x18\x04\x20\x01(\tR\nvisibility\x12\x12\n\x04type\x18\x05\x20\x01(\
    \tR\x04type\x12\x1a\n\x08abstract\x18\x06\x20\x02(\x08R\x08abstract\x12\
    \x16\n\x06sealed\x18\x07\x20\x02(\x08R\x06sealed\x12\x83\x01\n\x14number\
    _of_base_types\x18\x08\x20\x02(\x04R\x11numberOfBaseTypesBR\x82\x93\x19N\
    2L\n\x18this\x20field\x20is\x20deprecated\x12\x1euse\x20`base_types.len(\
    )`\x20instead\x1a\x10base_types.len()\x12\xa3\x01\n\x1cnumber_of_generic\
    _parameters\x18\t\x20\x02(\x04R\x19numberOfGenericParametersBb\x82\x93\
    \x19^2\\\n\x18this\x20field\x20is\x20deprecated\x12&use\x20`generic_para\
    meters.len()`\x20instead\x1a\x18generic_parameters.len()\x12x\n\x11numbe\
    r_of_methods\x18\n\x20\x02(\x04R\x0fnumberOfMethodsBL\x82\x93\x19H2F\n\
    \x18this\x20field\x20is\x20deprecated\x12\x1buse\x20`methods.len()`\x20i\
    nstead\x1a\rmethods.len()\x12\x1d\n\nbase_types\x18\x0b\x20\x03(\tR\tbas\
    eTypes\x12-\n\x12generic_parameters\x18\x0c\x20\x03(\tR\x11genericParame\
    ters\x12(\n\x07methods\x18\r\x20\x03(\x0b2\x0e.dotnet.MethodR\x07methods\
    \"\xcc\x04\n\x06Method\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
    \x1e\n\nvisibility\x18\x02\x20\x01(\tR\nvisibility\x12\x1a\n\x08abstract\
    \x18\x03\x20\x02(\x08R\x08abstract\x12\x16\n\x06static\x18\x04\x20\x02(\
    \x08R\x06static\x12\x18\n\x07virtual\x18\x05\x20\x02(\x08R\x07virtual\
    \x12\x14\n\x05final\x18\x06\x20\x02(\x08R\x05final\x12\x1f\n\x0breturn_t\
    ype\x18\x07\x20\x01(\tR\nreturnType\x12\xa3\x01\n\x1cnumber_of_generic_p\
    arameters\x18\x08\x20\x02(\x04R\x19numberOfGenericParametersBb\x82\x93\
    \x19^2\\\n\x18this\x20field\x20is\x20deprecated\x12&use\x20`generic_para\
    meters.len()`\x20instead\x1a\x18generic_parameters.len()\x12\x84\x01\n\
    \x14number_of_parameters\x18\t\x20\x02(\x04R\x12numberOfParametersBR\x82\
    \x93\x19N2L\n\x18this\x20field\x20is\x20deprecated\x12\x1euse\x20`parame\
    ters.len()`\x20instead\x1a\x10parameters.len()\x12-\n\x12generic_paramet\
    ers\x18\n\x20\x03(\tR\x11genericParameters\x12-\n\nparameters\x18\x0b\
    \x20\x03(\x0b2\r.dotnet.ParamR\nparameters\"/\n\x05Param\x12\x12\n\x04na\
    me\x18\x01\x20\x02(\tR\x04name\x12\x12\n\x04type\x18\x02\x20\x01(\tR\x04\
    typeB2\xfa\x92\x19.\n\x06dotnet\x12\rdotnet.Dotnet\x1a\x06dotnet\"\rdotn\
    et-moduleb\x06proto2\
";

/// `FileDescriptorProto` object which was a source for this generated file
fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
    file_descriptor_proto_lazy.get(|| {
        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
    })
}

/// `FileDescriptor` object which allows dynamic access to files
pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
    file_descriptor.get(|| {
        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
            let mut deps = ::std::vec::Vec::with_capacity(1);
            deps.push(super::yara::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(9);
            messages.push(Dotnet::generated_message_descriptor_data());
            messages.push(Assembly::generated_message_descriptor_data());
            messages.push(AssemblyRef::generated_message_descriptor_data());
            messages.push(Stream::generated_message_descriptor_data());
            messages.push(Version::generated_message_descriptor_data());
            messages.push(Resource::generated_message_descriptor_data());
            messages.push(Class::generated_message_descriptor_data());
            messages.push(Method::generated_message_descriptor_data());
            messages.push(Param::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(0);
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}