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 `vt/vtnet.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:vt.net.Subject)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Subject {
    // message fields
    // @@protoc_insertion_point(field:vt.net.Subject.common_name)
    pub common_name: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Subject.country)
    pub country: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Subject.organization)
    pub organization: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Subject.organizational_unit)
    pub organizational_unit: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Subject.locality)
    pub locality: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Subject.state)
    pub state: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.Subject.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(6);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "common_name",
            |m: &Subject| { &m.common_name },
            |m: &mut Subject| { &mut m.common_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "country",
            |m: &Subject| { &m.country },
            |m: &mut Subject| { &mut m.country },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "organization",
            |m: &Subject| { &m.organization },
            |m: &mut Subject| { &mut m.organization },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "organizational_unit",
            |m: &Subject| { &m.organizational_unit },
            |m: &mut Subject| { &mut m.organizational_unit },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "locality",
            |m: &Subject| { &m.locality },
            |m: &mut Subject| { &mut m.locality },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "state",
            |m: &Subject| { &m.state },
            |m: &mut Subject| { &mut m.state },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Subject>(
            "Subject",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.common_name = is.read_string()?;
                },
                18 => {
                    self.country = is.read_string()?;
                },
                26 => {
                    self.organization = is.read_string()?;
                },
                34 => {
                    self.organizational_unit = is.read_string()?;
                },
                42 => {
                    self.locality = is.read_string()?;
                },
                50 => {
                    self.state = 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 !self.common_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.common_name);
        }
        if !self.country.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.country);
        }
        if !self.organization.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.organization);
        }
        if !self.organizational_unit.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.organizational_unit);
        }
        if !self.locality.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.locality);
        }
        if !self.state.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.state);
        }
        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 !self.common_name.is_empty() {
            os.write_string(1, &self.common_name)?;
        }
        if !self.country.is_empty() {
            os.write_string(2, &self.country)?;
        }
        if !self.organization.is_empty() {
            os.write_string(3, &self.organization)?;
        }
        if !self.organizational_unit.is_empty() {
            os.write_string(4, &self.organizational_unit)?;
        }
        if !self.locality.is_empty() {
            os.write_string(5, &self.locality)?;
        }
        if !self.state.is_empty() {
            os.write_string(6, &self.state)?;
        }
        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() -> Subject {
        Subject::new()
    }

    fn clear(&mut self) {
        self.common_name.clear();
        self.country.clear();
        self.organization.clear();
        self.organizational_unit.clear();
        self.locality.clear();
        self.state.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Subject {
        static instance: Subject = Subject {
            common_name: ::std::string::String::new(),
            country: ::std::string::String::new(),
            organization: ::std::string::String::new(),
            organizational_unit: ::std::string::String::new(),
            locality: ::std::string::String::new(),
            state: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Subject {
    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("Subject").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.Validity)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Validity {
    // message fields
    // @@protoc_insertion_point(field:vt.net.Validity.not_after)
    pub not_after: i64,
    // @@protoc_insertion_point(field:vt.net.Validity.not_before)
    pub not_before: i64,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.Validity.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "not_after",
            |m: &Validity| { &m.not_after },
            |m: &mut Validity| { &mut m.not_after },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "not_before",
            |m: &Validity| { &m.not_before },
            |m: &mut Validity| { &mut m.not_before },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Validity>(
            "Validity",
            fields,
            oneofs,
        )
    }
}

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

    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.not_after = is.read_int64()?;
                },
                16 => {
                    self.not_before = is.read_int64()?;
                },
                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 self.not_after != 0 {
            my_size += ::protobuf::rt::int64_size(1, self.not_after);
        }
        if self.not_before != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.not_before);
        }
        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 self.not_after != 0 {
            os.write_int64(1, self.not_after)?;
        }
        if self.not_before != 0 {
            os.write_int64(2, self.not_before)?;
        }
        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() -> Validity {
        Validity::new()
    }

    fn clear(&mut self) {
        self.not_after = 0;
        self.not_before = 0;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Validity {
        static instance: Validity = Validity {
            not_after: 0,
            not_before: 0,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Validity {
    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("Validity").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.SSLCertificate)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct SSLCertificate {
    // message fields
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.thumbprint)
    pub thumbprint: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.subject)
    pub subject: ::protobuf::MessageField<Subject>,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.validity)
    pub validity: ::protobuf::MessageField<Validity>,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.subject_alternative_name)
    pub subject_alternative_name: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.signature)
    pub signature: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.serial_number)
    pub serial_number: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.SSLCertificate.issuer)
    pub issuer: ::protobuf::MessageField<Subject>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.SSLCertificate.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(7);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "thumbprint",
            |m: &SSLCertificate| { &m.thumbprint },
            |m: &mut SSLCertificate| { &mut m.thumbprint },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Subject>(
            "subject",
            |m: &SSLCertificate| { &m.subject },
            |m: &mut SSLCertificate| { &mut m.subject },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Validity>(
            "validity",
            |m: &SSLCertificate| { &m.validity },
            |m: &mut SSLCertificate| { &mut m.validity },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "subject_alternative_name",
            |m: &SSLCertificate| { &m.subject_alternative_name },
            |m: &mut SSLCertificate| { &mut m.subject_alternative_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "signature",
            |m: &SSLCertificate| { &m.signature },
            |m: &mut SSLCertificate| { &mut m.signature },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "serial_number",
            |m: &SSLCertificate| { &m.serial_number },
            |m: &mut SSLCertificate| { &mut m.serial_number },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Subject>(
            "issuer",
            |m: &SSLCertificate| { &m.issuer },
            |m: &mut SSLCertificate| { &mut m.issuer },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SSLCertificate>(
            "SSLCertificate",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.thumbprint = is.read_string()?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.subject)?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.validity)?;
                },
                34 => {
                    self.subject_alternative_name.push(is.read_string()?);
                },
                42 => {
                    self.signature = is.read_string()?;
                },
                50 => {
                    self.serial_number = is.read_string()?;
                },
                58 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.issuer)?;
                },
                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 !self.thumbprint.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.thumbprint);
        }
        if let Some(v) = self.subject.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.validity.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.subject_alternative_name {
            my_size += ::protobuf::rt::string_size(4, &value);
        };
        if !self.signature.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.signature);
        }
        if !self.serial_number.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.serial_number);
        }
        if let Some(v) = self.issuer.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 !self.thumbprint.is_empty() {
            os.write_string(1, &self.thumbprint)?;
        }
        if let Some(v) = self.subject.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.validity.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        for v in &self.subject_alternative_name {
            os.write_string(4, &v)?;
        };
        if !self.signature.is_empty() {
            os.write_string(5, &self.signature)?;
        }
        if !self.serial_number.is_empty() {
            os.write_string(6, &self.serial_number)?;
        }
        if let Some(v) = self.issuer.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(7, 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() -> SSLCertificate {
        SSLCertificate::new()
    }

    fn clear(&mut self) {
        self.thumbprint.clear();
        self.subject.clear();
        self.validity.clear();
        self.subject_alternative_name.clear();
        self.signature.clear();
        self.serial_number.clear();
        self.issuer.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static SSLCertificate {
        static instance: SSLCertificate = SSLCertificate {
            thumbprint: ::std::string::String::new(),
            subject: ::protobuf::MessageField::none(),
            validity: ::protobuf::MessageField::none(),
            subject_alternative_name: ::std::vec::Vec::new(),
            signature: ::std::string::String::new(),
            serial_number: ::std::string::String::new(),
            issuer: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for SSLCertificate {
    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("SSLCertificate").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.Tracker)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Tracker {
    // message fields
    // @@protoc_insertion_point(field:vt.net.Tracker.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Tracker.id)
    pub id: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Tracker.url)
    pub url: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.Tracker.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "name",
            |m: &Tracker| { &m.name },
            |m: &mut Tracker| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "id",
            |m: &Tracker| { &m.id },
            |m: &mut Tracker| { &mut m.id },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "url",
            |m: &Tracker| { &m.url },
            |m: &mut Tracker| { &mut m.url },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Tracker>(
            "Tracker",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.name = is.read_string()?;
                },
                18 => {
                    self.id = is.read_string()?;
                },
                26 => {
                    self.url = 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 !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if !self.id.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.id);
        }
        if !self.url.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.url);
        }
        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 !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if !self.id.is_empty() {
            os.write_string(2, &self.id)?;
        }
        if !self.url.is_empty() {
            os.write_string(3, &self.url)?;
        }
        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() -> Tracker {
        Tracker::new()
    }

    fn clear(&mut self) {
        self.name.clear();
        self.id.clear();
        self.url.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Tracker {
        static instance: Tracker = Tracker {
            name: ::std::string::String::new(),
            id: ::std::string::String::new(),
            url: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Tracker {
    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("Tracker").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.DNSRecord)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DNSRecord {
    // message fields
    // @@protoc_insertion_point(field:vt.net.DNSRecord.type)
    pub type_: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.dns_class)
    pub dns_class: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.ttl)
    pub ttl: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.mname)
    pub mname: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.rname)
    pub rname: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.priority)
    pub priority: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.serial)
    pub serial: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.retry)
    pub retry: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.refresh)
    pub refresh: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.expire)
    pub expire: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.minimum)
    pub minimum: i64,
    // @@protoc_insertion_point(field:vt.net.DNSRecord.value)
    pub value: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.DNSRecord.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(12);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "type",
            |m: &DNSRecord| { &m.type_ },
            |m: &mut DNSRecord| { &mut m.type_ },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "dns_class",
            |m: &DNSRecord| { &m.dns_class },
            |m: &mut DNSRecord| { &mut m.dns_class },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ttl",
            |m: &DNSRecord| { &m.ttl },
            |m: &mut DNSRecord| { &mut m.ttl },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "mname",
            |m: &DNSRecord| { &m.mname },
            |m: &mut DNSRecord| { &mut m.mname },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "rname",
            |m: &DNSRecord| { &m.rname },
            |m: &mut DNSRecord| { &mut m.rname },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "priority",
            |m: &DNSRecord| { &m.priority },
            |m: &mut DNSRecord| { &mut m.priority },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "serial",
            |m: &DNSRecord| { &m.serial },
            |m: &mut DNSRecord| { &mut m.serial },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "retry",
            |m: &DNSRecord| { &m.retry },
            |m: &mut DNSRecord| { &mut m.retry },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "refresh",
            |m: &DNSRecord| { &m.refresh },
            |m: &mut DNSRecord| { &mut m.refresh },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "expire",
            |m: &DNSRecord| { &m.expire },
            |m: &mut DNSRecord| { &mut m.expire },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "minimum",
            |m: &DNSRecord| { &m.minimum },
            |m: &mut DNSRecord| { &mut m.minimum },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "value",
            |m: &DNSRecord| { &m.value },
            |m: &mut DNSRecord| { &mut m.value },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DNSRecord>(
            "DNSRecord",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                18 => {
                    self.type_ = is.read_string()?;
                },
                26 => {
                    self.dns_class = is.read_string()?;
                },
                32 => {
                    self.ttl = is.read_int64()?;
                },
                42 => {
                    self.mname = is.read_string()?;
                },
                50 => {
                    self.rname = is.read_string()?;
                },
                56 => {
                    self.priority = is.read_int64()?;
                },
                64 => {
                    self.serial = is.read_int64()?;
                },
                72 => {
                    self.retry = is.read_int64()?;
                },
                80 => {
                    self.refresh = is.read_int64()?;
                },
                88 => {
                    self.expire = is.read_int64()?;
                },
                96 => {
                    self.minimum = is.read_int64()?;
                },
                106 => {
                    self.value = 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 !self.type_.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.type_);
        }
        if !self.dns_class.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.dns_class);
        }
        if self.ttl != 0 {
            my_size += ::protobuf::rt::int64_size(4, self.ttl);
        }
        if !self.mname.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.mname);
        }
        if !self.rname.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.rname);
        }
        if self.priority != 0 {
            my_size += ::protobuf::rt::int64_size(7, self.priority);
        }
        if self.serial != 0 {
            my_size += ::protobuf::rt::int64_size(8, self.serial);
        }
        if self.retry != 0 {
            my_size += ::protobuf::rt::int64_size(9, self.retry);
        }
        if self.refresh != 0 {
            my_size += ::protobuf::rt::int64_size(10, self.refresh);
        }
        if self.expire != 0 {
            my_size += ::protobuf::rt::int64_size(11, self.expire);
        }
        if self.minimum != 0 {
            my_size += ::protobuf::rt::int64_size(12, self.minimum);
        }
        if !self.value.is_empty() {
            my_size += ::protobuf::rt::string_size(13, &self.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 !self.type_.is_empty() {
            os.write_string(2, &self.type_)?;
        }
        if !self.dns_class.is_empty() {
            os.write_string(3, &self.dns_class)?;
        }
        if self.ttl != 0 {
            os.write_int64(4, self.ttl)?;
        }
        if !self.mname.is_empty() {
            os.write_string(5, &self.mname)?;
        }
        if !self.rname.is_empty() {
            os.write_string(6, &self.rname)?;
        }
        if self.priority != 0 {
            os.write_int64(7, self.priority)?;
        }
        if self.serial != 0 {
            os.write_int64(8, self.serial)?;
        }
        if self.retry != 0 {
            os.write_int64(9, self.retry)?;
        }
        if self.refresh != 0 {
            os.write_int64(10, self.refresh)?;
        }
        if self.expire != 0 {
            os.write_int64(11, self.expire)?;
        }
        if self.minimum != 0 {
            os.write_int64(12, self.minimum)?;
        }
        if !self.value.is_empty() {
            os.write_string(13, &self.value)?;
        }
        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() -> DNSRecord {
        DNSRecord::new()
    }

    fn clear(&mut self) {
        self.type_.clear();
        self.dns_class.clear();
        self.ttl = 0;
        self.mname.clear();
        self.rname.clear();
        self.priority = 0;
        self.serial = 0;
        self.retry = 0;
        self.refresh = 0;
        self.expire = 0;
        self.minimum = 0;
        self.value.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DNSRecord {
        static instance: DNSRecord = DNSRecord {
            type_: ::std::string::String::new(),
            dns_class: ::std::string::String::new(),
            ttl: 0,
            mname: ::std::string::String::new(),
            rname: ::std::string::String::new(),
            priority: 0,
            serial: 0,
            retry: 0,
            refresh: 0,
            expire: 0,
            minimum: 0,
            value: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for DNSRecord {
    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("DNSRecord").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.Favicon)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Favicon {
    // message fields
    // @@protoc_insertion_point(field:vt.net.Favicon.raw_md5)
    pub raw_md5: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.Favicon.dhash)
    pub dhash: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.Favicon.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "raw_md5",
            |m: &Favicon| { &m.raw_md5 },
            |m: &mut Favicon| { &mut m.raw_md5 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "dhash",
            |m: &Favicon| { &m.dhash },
            |m: &mut Favicon| { &mut m.dhash },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Favicon>(
            "Favicon",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.raw_md5 = is.read_string()?;
                },
                18 => {
                    self.dhash = 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 !self.raw_md5.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.raw_md5);
        }
        if !self.dhash.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.dhash);
        }
        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 !self.raw_md5.is_empty() {
            os.write_string(1, &self.raw_md5)?;
        }
        if !self.dhash.is_empty() {
            os.write_string(2, &self.dhash)?;
        }
        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() -> Favicon {
        Favicon::new()
    }

    fn clear(&mut self) {
        self.raw_md5.clear();
        self.dhash.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Favicon {
        static instance: Favicon = Favicon {
            raw_md5: ::std::string::String::new(),
            dhash: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for Favicon {
    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("Favicon").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.KeyValue)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct KeyValue {
    // message fields
    // @@protoc_insertion_point(field:vt.net.KeyValue.key)
    pub key: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.KeyValue.values)
    pub values: ::std::vec::Vec<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.KeyValue.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "key",
            |m: &KeyValue| { &m.key },
            |m: &mut KeyValue| { &mut m.key },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "values",
            |m: &KeyValue| { &m.values },
            |m: &mut KeyValue| { &mut m.values },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<KeyValue>(
            "KeyValue",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.key = is.read_string()?;
                },
                18 => {
                    self.values.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 !self.key.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.key);
        }
        for value in &self.values {
            my_size += ::protobuf::rt::string_size(2, &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 !self.key.is_empty() {
            os.write_string(1, &self.key)?;
        }
        for v in &self.values {
            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() -> KeyValue {
        KeyValue::new()
    }

    fn clear(&mut self) {
        self.key.clear();
        self.values.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static KeyValue {
        static instance: KeyValue = KeyValue {
            key: ::std::string::String::new(),
            values: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for KeyValue {
    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("KeyValue").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.FileMetadata)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct FileMetadata {
    // message fields
    // @@protoc_insertion_point(field:vt.net.FileMetadata.sha256)
    pub sha256: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.new_for_vt)
    pub new_for_vt: bool,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.analysis_stats)
    pub analysis_stats: ::protobuf::MessageField<super::analysis::AnalysisStats>,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.file_type)
    pub file_type: ::protobuf::EnumOrUnknown<super::filetypes::FileType>,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.new_for_url)
    pub new_for_url: bool,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.new_for_ip)
    pub new_for_ip: bool,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.new_for_domain)
    pub new_for_domain: bool,
    // @@protoc_insertion_point(field:vt.net.FileMetadata.signatures)
    pub signatures: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.FileMetadata.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(8);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "sha256",
            |m: &FileMetadata| { &m.sha256 },
            |m: &mut FileMetadata| { &mut m.sha256 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_for_vt",
            |m: &FileMetadata| { &m.new_for_vt },
            |m: &mut FileMetadata| { &mut m.new_for_vt },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::analysis::AnalysisStats>(
            "analysis_stats",
            |m: &FileMetadata| { &m.analysis_stats },
            |m: &mut FileMetadata| { &mut m.analysis_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "file_type",
            |m: &FileMetadata| { &m.file_type },
            |m: &mut FileMetadata| { &mut m.file_type },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_for_url",
            |m: &FileMetadata| { &m.new_for_url },
            |m: &mut FileMetadata| { &mut m.new_for_url },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_for_ip",
            |m: &FileMetadata| { &m.new_for_ip },
            |m: &mut FileMetadata| { &mut m.new_for_ip },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_for_domain",
            |m: &FileMetadata| { &m.new_for_domain },
            |m: &mut FileMetadata| { &mut m.new_for_domain },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "signatures",
            |m: &FileMetadata| { &m.signatures },
            |m: &mut FileMetadata| { &mut m.signatures },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FileMetadata>(
            "FileMetadata",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.sha256 = is.read_string()?;
                },
                24 => {
                    self.new_for_vt = is.read_bool()?;
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.analysis_stats)?;
                },
                48 => {
                    self.file_type = is.read_enum_or_unknown()?;
                },
                56 => {
                    self.new_for_url = is.read_bool()?;
                },
                64 => {
                    self.new_for_ip = is.read_bool()?;
                },
                72 => {
                    self.new_for_domain = is.read_bool()?;
                },
                82 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.signatures.insert(key, value);
                },
                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 !self.sha256.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.sha256);
        }
        if self.new_for_vt != false {
            my_size += 1 + 1;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.file_type != ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(6, self.file_type.value());
        }
        if self.new_for_url != false {
            my_size += 1 + 1;
        }
        if self.new_for_ip != false {
            my_size += 1 + 1;
        }
        if self.new_for_domain != false {
            my_size += 1 + 1;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        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 !self.sha256.is_empty() {
            os.write_string(1, &self.sha256)?;
        }
        if self.new_for_vt != false {
            os.write_bool(3, self.new_for_vt)?;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        if self.file_type != ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN) {
            os.write_enum(6, ::protobuf::EnumOrUnknown::value(&self.file_type))?;
        }
        if self.new_for_url != false {
            os.write_bool(7, self.new_for_url)?;
        }
        if self.new_for_ip != false {
            os.write_bool(8, self.new_for_ip)?;
        }
        if self.new_for_domain != false {
            os.write_bool(9, self.new_for_domain)?;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(82)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            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() -> FileMetadata {
        FileMetadata::new()
    }

    fn clear(&mut self) {
        self.sha256.clear();
        self.new_for_vt = false;
        self.analysis_stats.clear();
        self.file_type = ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN);
        self.new_for_url = false;
        self.new_for_ip = false;
        self.new_for_domain = false;
        self.signatures.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static FileMetadata {
        static instance: ::protobuf::rt::Lazy<FileMetadata> = ::protobuf::rt::Lazy::new();
        instance.get(FileMetadata::new)
    }
}

impl ::protobuf::MessageFull for FileMetadata {
    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("FileMetadata").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.ResourceFileMetadata)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ResourceFileMetadata {
    // message fields
    // @@protoc_insertion_point(field:vt.net.ResourceFileMetadata.sha256)
    pub sha256: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.ResourceFileMetadata.analysis_stats)
    pub analysis_stats: ::protobuf::MessageField<super::analysis::AnalysisStats>,
    // @@protoc_insertion_point(field:vt.net.ResourceFileMetadata.file_type)
    pub file_type: ::protobuf::EnumOrUnknown<super::filetypes::FileType>,
    // @@protoc_insertion_point(field:vt.net.ResourceFileMetadata.new_for_url)
    pub new_for_url: bool,
    // @@protoc_insertion_point(field:vt.net.ResourceFileMetadata.signatures)
    pub signatures: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.ResourceFileMetadata.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(5);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "sha256",
            |m: &ResourceFileMetadata| { &m.sha256 },
            |m: &mut ResourceFileMetadata| { &mut m.sha256 },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::analysis::AnalysisStats>(
            "analysis_stats",
            |m: &ResourceFileMetadata| { &m.analysis_stats },
            |m: &mut ResourceFileMetadata| { &mut m.analysis_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "file_type",
            |m: &ResourceFileMetadata| { &m.file_type },
            |m: &mut ResourceFileMetadata| { &mut m.file_type },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_for_url",
            |m: &ResourceFileMetadata| { &m.new_for_url },
            |m: &mut ResourceFileMetadata| { &mut m.new_for_url },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "signatures",
            |m: &ResourceFileMetadata| { &m.signatures },
            |m: &mut ResourceFileMetadata| { &mut m.signatures },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ResourceFileMetadata>(
            "ResourceFileMetadata",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    self.sha256 = is.read_string()?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.analysis_stats)?;
                },
                24 => {
                    self.file_type = is.read_enum_or_unknown()?;
                },
                32 => {
                    self.new_for_url = is.read_bool()?;
                },
                42 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.signatures.insert(key, value);
                },
                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 !self.sha256.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.sha256);
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.file_type != ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN) {
            my_size += ::protobuf::rt::int32_size(3, self.file_type.value());
        }
        if self.new_for_url != false {
            my_size += 1 + 1;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        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 !self.sha256.is_empty() {
            os.write_string(1, &self.sha256)?;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if self.file_type != ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN) {
            os.write_enum(3, ::protobuf::EnumOrUnknown::value(&self.file_type))?;
        }
        if self.new_for_url != false {
            os.write_bool(4, self.new_for_url)?;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(42)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            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() -> ResourceFileMetadata {
        ResourceFileMetadata::new()
    }

    fn clear(&mut self) {
        self.sha256.clear();
        self.analysis_stats.clear();
        self.file_type = ::protobuf::EnumOrUnknown::new(super::filetypes::FileType::UNKNOWN);
        self.new_for_url = false;
        self.signatures.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ResourceFileMetadata {
        static instance: ::protobuf::rt::Lazy<ResourceFileMetadata> = ::protobuf::rt::Lazy::new();
        instance.get(ResourceFileMetadata::new)
    }
}

impl ::protobuf::MessageFull for ResourceFileMetadata {
    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("ResourceFileMetadata").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.PopularityRank)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PopularityRank {
    // message fields
    // @@protoc_insertion_point(field:vt.net.PopularityRank.position)
    pub position: i64,
    // @@protoc_insertion_point(field:vt.net.PopularityRank.ingestion_time)
    pub ingestion_time: i64,
    // @@protoc_insertion_point(field:vt.net.PopularityRank.rank)
    pub rank: ::std::string::String,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.PopularityRank.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "position",
            |m: &PopularityRank| { &m.position },
            |m: &mut PopularityRank| { &mut m.position },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ingestion_time",
            |m: &PopularityRank| { &m.ingestion_time },
            |m: &mut PopularityRank| { &mut m.ingestion_time },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "rank",
            |m: &PopularityRank| { &m.rank },
            |m: &mut PopularityRank| { &mut m.rank },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PopularityRank>(
            "PopularityRank",
            fields,
            oneofs,
        )
    }
}

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

    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.position = is.read_int64()?;
                },
                16 => {
                    self.ingestion_time = is.read_int64()?;
                },
                26 => {
                    self.rank = 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 self.position != 0 {
            my_size += ::protobuf::rt::int64_size(1, self.position);
        }
        if self.ingestion_time != 0 {
            my_size += ::protobuf::rt::int64_size(2, self.ingestion_time);
        }
        if !self.rank.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.rank);
        }
        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 self.position != 0 {
            os.write_int64(1, self.position)?;
        }
        if self.ingestion_time != 0 {
            os.write_int64(2, self.ingestion_time)?;
        }
        if !self.rank.is_empty() {
            os.write_string(3, &self.rank)?;
        }
        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() -> PopularityRank {
        PopularityRank::new()
    }

    fn clear(&mut self) {
        self.position = 0;
        self.ingestion_time = 0;
        self.rank.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PopularityRank {
        static instance: PopularityRank = PopularityRank {
            position: 0,
            ingestion_time: 0,
            rank: ::std::string::String::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for PopularityRank {
    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("PopularityRank").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.EnrichedURL)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct EnrichedURL {
    // message fields
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.port)
    pub port: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.trackers)
    pub trackers: ::std::vec::Vec<Tracker>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.response_headers)
    pub response_headers: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.number_of_response_headers)
    pub number_of_response_headers: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.response_code)
    pub response_code: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.cookies)
    pub cookies: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.favicon)
    pub favicon: ::protobuf::MessageField<Favicon>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.outgoing_links)
    pub outgoing_links: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.redirects)
    pub redirects: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.html_title)
    pub html_title: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.html_meta_tags)
    pub html_meta_tags: ::std::vec::Vec<KeyValue>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.new_url)
    pub new_url: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.analysis_stats)
    pub analysis_stats: ::protobuf::MessageField<super::analysis::AnalysisStats>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.first_submission_date)
    pub first_submission_date: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.signatures)
    pub signatures: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.submitter)
    pub submitter: ::protobuf::MessageField<super::submitter::Submitter>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.tags)
    pub tags: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.query)
    pub query: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.params)
    pub params: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.path)
    pub path: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.hostname)
    pub hostname: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.raw)
    pub raw: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.downloaded_file)
    pub downloaded_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.communicating_file)
    pub communicating_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.embedded_resources)
    pub embedded_resources: ::std::vec::Vec<ResourceFileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.categories)
    pub categories: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedURL.gti_assessment)
    pub gti_assessment: ::protobuf::MessageField<super::hunting_gti_score::HuntingGtiScore>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.EnrichedURL.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(27);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "port",
            |m: &EnrichedURL| { &m.port },
            |m: &mut EnrichedURL| { &mut m.port },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "trackers",
            |m: &EnrichedURL| { &m.trackers },
            |m: &mut EnrichedURL| { &mut m.trackers },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "response_headers",
            |m: &EnrichedURL| { &m.response_headers },
            |m: &mut EnrichedURL| { &mut m.response_headers },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "number_of_response_headers",
            |m: &EnrichedURL| { &m.number_of_response_headers },
            |m: &mut EnrichedURL| { &mut m.number_of_response_headers },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "response_code",
            |m: &EnrichedURL| { &m.response_code },
            |m: &mut EnrichedURL| { &mut m.response_code },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "cookies",
            |m: &EnrichedURL| { &m.cookies },
            |m: &mut EnrichedURL| { &mut m.cookies },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Favicon>(
            "favicon",
            |m: &EnrichedURL| { &m.favicon },
            |m: &mut EnrichedURL| { &mut m.favicon },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "outgoing_links",
            |m: &EnrichedURL| { &m.outgoing_links },
            |m: &mut EnrichedURL| { &mut m.outgoing_links },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "redirects",
            |m: &EnrichedURL| { &m.redirects },
            |m: &mut EnrichedURL| { &mut m.redirects },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "html_title",
            |m: &EnrichedURL| { &m.html_title },
            |m: &mut EnrichedURL| { &mut m.html_title },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "html_meta_tags",
            |m: &EnrichedURL| { &m.html_meta_tags },
            |m: &mut EnrichedURL| { &mut m.html_meta_tags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_url",
            |m: &EnrichedURL| { &m.new_url },
            |m: &mut EnrichedURL| { &mut m.new_url },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::analysis::AnalysisStats>(
            "analysis_stats",
            |m: &EnrichedURL| { &m.analysis_stats },
            |m: &mut EnrichedURL| { &mut m.analysis_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "first_submission_date",
            |m: &EnrichedURL| { &m.first_submission_date },
            |m: &mut EnrichedURL| { &mut m.first_submission_date },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "signatures",
            |m: &EnrichedURL| { &m.signatures },
            |m: &mut EnrichedURL| { &mut m.signatures },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::submitter::Submitter>(
            "submitter",
            |m: &EnrichedURL| { &m.submitter },
            |m: &mut EnrichedURL| { &mut m.submitter },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "tags",
            |m: &EnrichedURL| { &m.tags },
            |m: &mut EnrichedURL| { &mut m.tags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "query",
            |m: &EnrichedURL| { &m.query },
            |m: &mut EnrichedURL| { &mut m.query },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "params",
            |m: &EnrichedURL| { &m.params },
            |m: &mut EnrichedURL| { &mut m.params },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "path",
            |m: &EnrichedURL| { &m.path },
            |m: &mut EnrichedURL| { &mut m.path },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "hostname",
            |m: &EnrichedURL| { &m.hostname },
            |m: &mut EnrichedURL| { &mut m.hostname },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "raw",
            |m: &EnrichedURL| { &m.raw },
            |m: &mut EnrichedURL| { &mut m.raw },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "downloaded_file",
            |m: &EnrichedURL| { &m.downloaded_file },
            |m: &mut EnrichedURL| { &mut m.downloaded_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "communicating_file",
            |m: &EnrichedURL| { &m.communicating_file },
            |m: &mut EnrichedURL| { &mut m.communicating_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "embedded_resources",
            |m: &EnrichedURL| { &m.embedded_resources },
            |m: &mut EnrichedURL| { &mut m.embedded_resources },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "categories",
            |m: &EnrichedURL| { &m.categories },
            |m: &mut EnrichedURL| { &mut m.categories },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::hunting_gti_score::HuntingGtiScore>(
            "gti_assessment",
            |m: &EnrichedURL| { &m.gti_assessment },
            |m: &mut EnrichedURL| { &mut m.gti_assessment },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnrichedURL>(
            "EnrichedURL",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                24 => {
                    self.port = is.read_int64()?;
                },
                34 => {
                    self.trackers.push(is.read_message()?);
                },
                42 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.response_headers.insert(key, value);
                },
                264 => {
                    self.number_of_response_headers = is.read_int64()?;
                },
                48 => {
                    self.response_code = is.read_int64()?;
                },
                58 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.cookies.insert(key, value);
                },
                66 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.favicon)?;
                },
                74 => {
                    self.outgoing_links.push(is.read_string()?);
                },
                82 => {
                    self.redirects.push(is.read_string()?);
                },
                90 => {
                    self.html_title = is.read_string()?;
                },
                98 => {
                    self.html_meta_tags.push(is.read_message()?);
                },
                136 => {
                    self.new_url = is.read_bool()?;
                },
                146 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.analysis_stats)?;
                },
                152 => {
                    self.first_submission_date = is.read_int64()?;
                },
                162 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.signatures.insert(key, value);
                },
                170 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.submitter)?;
                },
                194 => {
                    self.tags.push(is.read_string()?);
                },
                274 => {
                    self.query = is.read_string()?;
                },
                202 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.params.insert(key, value);
                },
                210 => {
                    self.path = is.read_string()?;
                },
                218 => {
                    self.hostname = is.read_string()?;
                },
                226 => {
                    self.raw = is.read_string()?;
                },
                234 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.downloaded_file)?;
                },
                242 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.communicating_file)?;
                },
                250 => {
                    self.embedded_resources.push(is.read_message()?);
                },
                282 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.categories.insert(key, value);
                },
                314 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.gti_assessment)?;
                },
                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 self.port != 0 {
            my_size += ::protobuf::rt::int64_size(3, self.port);
        }
        for value in &self.trackers {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for (k, v) in &self.response_headers {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if self.number_of_response_headers != 0 {
            my_size += ::protobuf::rt::int64_size(33, self.number_of_response_headers);
        }
        if self.response_code != 0 {
            my_size += ::protobuf::rt::int64_size(6, self.response_code);
        }
        for (k, v) in &self.cookies {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if let Some(v) = self.favicon.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.outgoing_links {
            my_size += ::protobuf::rt::string_size(9, &value);
        };
        for value in &self.redirects {
            my_size += ::protobuf::rt::string_size(10, &value);
        };
        if !self.html_title.is_empty() {
            my_size += ::protobuf::rt::string_size(11, &self.html_title);
        }
        for value in &self.html_meta_tags {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.new_url != false {
            my_size += 2 + 1;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.first_submission_date != 0 {
            my_size += ::protobuf::rt::int64_size(19, self.first_submission_date);
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if let Some(v) = self.submitter.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.tags {
            my_size += ::protobuf::rt::string_size(24, &value);
        };
        if !self.query.is_empty() {
            my_size += ::protobuf::rt::string_size(34, &self.query);
        }
        for (k, v) in &self.params {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if !self.path.is_empty() {
            my_size += ::protobuf::rt::string_size(26, &self.path);
        }
        if !self.hostname.is_empty() {
            my_size += ::protobuf::rt::string_size(27, &self.hostname);
        }
        if !self.raw.is_empty() {
            my_size += ::protobuf::rt::string_size(28, &self.raw);
        }
        if let Some(v) = self.downloaded_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.embedded_resources {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for (k, v) in &self.categories {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if let Some(v) = self.gti_assessment.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::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 self.port != 0 {
            os.write_int64(3, self.port)?;
        }
        for v in &self.trackers {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for (k, v) in &self.response_headers {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(42)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if self.number_of_response_headers != 0 {
            os.write_int64(33, self.number_of_response_headers)?;
        }
        if self.response_code != 0 {
            os.write_int64(6, self.response_code)?;
        }
        for (k, v) in &self.cookies {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(58)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if let Some(v) = self.favicon.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?;
        }
        for v in &self.outgoing_links {
            os.write_string(9, &v)?;
        };
        for v in &self.redirects {
            os.write_string(10, &v)?;
        };
        if !self.html_title.is_empty() {
            os.write_string(11, &self.html_title)?;
        }
        for v in &self.html_meta_tags {
            ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
        };
        if self.new_url != false {
            os.write_bool(17, self.new_url)?;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(18, v, os)?;
        }
        if self.first_submission_date != 0 {
            os.write_int64(19, self.first_submission_date)?;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(162)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if let Some(v) = self.submitter.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(21, v, os)?;
        }
        for v in &self.tags {
            os.write_string(24, &v)?;
        };
        if !self.query.is_empty() {
            os.write_string(34, &self.query)?;
        }
        for (k, v) in &self.params {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(202)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if !self.path.is_empty() {
            os.write_string(26, &self.path)?;
        }
        if !self.hostname.is_empty() {
            os.write_string(27, &self.hostname)?;
        }
        if !self.raw.is_empty() {
            os.write_string(28, &self.raw)?;
        }
        if let Some(v) = self.downloaded_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(29, v, os)?;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(30, v, os)?;
        }
        for v in &self.embedded_resources {
            ::protobuf::rt::write_message_field_with_cached_size(31, v, os)?;
        };
        for (k, v) in &self.categories {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(282)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if let Some(v) = self.gti_assessment.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(39, 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() -> EnrichedURL {
        EnrichedURL::new()
    }

    fn clear(&mut self) {
        self.port = 0;
        self.trackers.clear();
        self.response_headers.clear();
        self.number_of_response_headers = 0;
        self.response_code = 0;
        self.cookies.clear();
        self.favicon.clear();
        self.outgoing_links.clear();
        self.redirects.clear();
        self.html_title.clear();
        self.html_meta_tags.clear();
        self.new_url = false;
        self.analysis_stats.clear();
        self.first_submission_date = 0;
        self.signatures.clear();
        self.submitter.clear();
        self.tags.clear();
        self.query.clear();
        self.params.clear();
        self.path.clear();
        self.hostname.clear();
        self.raw.clear();
        self.downloaded_file.clear();
        self.communicating_file.clear();
        self.embedded_resources.clear();
        self.categories.clear();
        self.gti_assessment.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static EnrichedURL {
        static instance: ::protobuf::rt::Lazy<EnrichedURL> = ::protobuf::rt::Lazy::new();
        instance.get(EnrichedURL::new)
    }
}

impl ::protobuf::MessageFull for EnrichedURL {
    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("EnrichedURL").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.EnrichedIP)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct EnrichedIP {
    // message fields
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.whois)
    pub whois: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.whois_raw)
    pub whois_raw: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.https_certificate)
    pub https_certificate: ::protobuf::MessageField<SSLCertificate>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.jarm)
    pub jarm: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.ip_as_owner)
    pub ip_as_owner: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.ip_asn)
    pub ip_asn: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.ip_country)
    pub ip_country: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.analysis_stats)
    pub analysis_stats: ::protobuf::MessageField<super::analysis::AnalysisStats>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.signatures)
    pub signatures: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.tags)
    pub tags: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.raw)
    pub raw: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.downloaded_file)
    pub downloaded_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.communicating_file)
    pub communicating_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.ip_as_int)
    pub ip_as_int: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.first_whois)
    pub first_whois: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.new_whois)
    pub new_whois: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.reverse_lookup)
    pub reverse_lookup: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedIP.gti_assessment)
    pub gti_assessment: ::protobuf::MessageField<super::hunting_gti_score::HuntingGtiScore>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.EnrichedIP.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
        let mut fields = ::std::vec::Vec::with_capacity(18);
        let mut oneofs = ::std::vec::Vec::with_capacity(0);
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "whois",
            |m: &EnrichedIP| { &m.whois },
            |m: &mut EnrichedIP| { &mut m.whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "whois_raw",
            |m: &EnrichedIP| { &m.whois_raw },
            |m: &mut EnrichedIP| { &mut m.whois_raw },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SSLCertificate>(
            "https_certificate",
            |m: &EnrichedIP| { &m.https_certificate },
            |m: &mut EnrichedIP| { &mut m.https_certificate },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "jarm",
            |m: &EnrichedIP| { &m.jarm },
            |m: &mut EnrichedIP| { &mut m.jarm },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ip_as_owner",
            |m: &EnrichedIP| { &m.ip_as_owner },
            |m: &mut EnrichedIP| { &mut m.ip_as_owner },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ip_asn",
            |m: &EnrichedIP| { &m.ip_asn },
            |m: &mut EnrichedIP| { &mut m.ip_asn },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ip_country",
            |m: &EnrichedIP| { &m.ip_country },
            |m: &mut EnrichedIP| { &mut m.ip_country },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::analysis::AnalysisStats>(
            "analysis_stats",
            |m: &EnrichedIP| { &m.analysis_stats },
            |m: &mut EnrichedIP| { &mut m.analysis_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "signatures",
            |m: &EnrichedIP| { &m.signatures },
            |m: &mut EnrichedIP| { &mut m.signatures },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "tags",
            |m: &EnrichedIP| { &m.tags },
            |m: &mut EnrichedIP| { &mut m.tags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "raw",
            |m: &EnrichedIP| { &m.raw },
            |m: &mut EnrichedIP| { &mut m.raw },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "downloaded_file",
            |m: &EnrichedIP| { &m.downloaded_file },
            |m: &mut EnrichedIP| { &mut m.downloaded_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "communicating_file",
            |m: &EnrichedIP| { &m.communicating_file },
            |m: &mut EnrichedIP| { &mut m.communicating_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "ip_as_int",
            |m: &EnrichedIP| { &m.ip_as_int },
            |m: &mut EnrichedIP| { &mut m.ip_as_int },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "first_whois",
            |m: &EnrichedIP| { &m.first_whois },
            |m: &mut EnrichedIP| { &mut m.first_whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_whois",
            |m: &EnrichedIP| { &m.new_whois },
            |m: &mut EnrichedIP| { &mut m.new_whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "reverse_lookup",
            |m: &EnrichedIP| { &m.reverse_lookup },
            |m: &mut EnrichedIP| { &mut m.reverse_lookup },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::hunting_gti_score::HuntingGtiScore>(
            "gti_assessment",
            |m: &EnrichedIP| { &m.gti_assessment },
            |m: &mut EnrichedIP| { &mut m.gti_assessment },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnrichedIP>(
            "EnrichedIP",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                26 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.whois.insert(key, value);
                },
                178 => {
                    self.whois_raw = is.read_string()?;
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.https_certificate)?;
                },
                42 => {
                    self.jarm = is.read_string()?;
                },
                50 => {
                    self.ip_as_owner = is.read_string()?;
                },
                56 => {
                    self.ip_asn = is.read_int64()?;
                },
                66 => {
                    self.ip_country = is.read_string()?;
                },
                106 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.analysis_stats)?;
                },
                114 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.signatures.insert(key, value);
                },
                138 => {
                    self.tags.push(is.read_string()?);
                },
                146 => {
                    self.raw = is.read_string()?;
                },
                154 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.downloaded_file)?;
                },
                162 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.communicating_file)?;
                },
                184 => {
                    self.ip_as_int = is.read_int64()?;
                },
                192 => {
                    self.first_whois = is.read_bool()?;
                },
                200 => {
                    self.new_whois = is.read_bool()?;
                },
                210 => {
                    self.reverse_lookup = is.read_string()?;
                },
                242 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.gti_assessment)?;
                },
                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;
        for (k, v) in &self.whois {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if !self.whois_raw.is_empty() {
            my_size += ::protobuf::rt::string_size(22, &self.whois_raw);
        }
        if let Some(v) = self.https_certificate.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.jarm.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.jarm);
        }
        if !self.ip_as_owner.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.ip_as_owner);
        }
        if self.ip_asn != 0 {
            my_size += ::protobuf::rt::int64_size(7, self.ip_asn);
        }
        if !self.ip_country.is_empty() {
            my_size += ::protobuf::rt::string_size(8, &self.ip_country);
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        for value in &self.tags {
            my_size += ::protobuf::rt::string_size(17, &value);
        };
        if !self.raw.is_empty() {
            my_size += ::protobuf::rt::string_size(18, &self.raw);
        }
        if let Some(v) = self.downloaded_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.ip_as_int != 0 {
            my_size += ::protobuf::rt::int64_size(23, self.ip_as_int);
        }
        if self.first_whois != false {
            my_size += 2 + 1;
        }
        if self.new_whois != false {
            my_size += 2 + 1;
        }
        if !self.reverse_lookup.is_empty() {
            my_size += ::protobuf::rt::string_size(26, &self.reverse_lookup);
        }
        if let Some(v) = self.gti_assessment.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::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<()> {
        for (k, v) in &self.whois {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(26)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if !self.whois_raw.is_empty() {
            os.write_string(22, &self.whois_raw)?;
        }
        if let Some(v) = self.https_certificate.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if !self.jarm.is_empty() {
            os.write_string(5, &self.jarm)?;
        }
        if !self.ip_as_owner.is_empty() {
            os.write_string(6, &self.ip_as_owner)?;
        }
        if self.ip_asn != 0 {
            os.write_int64(7, self.ip_asn)?;
        }
        if !self.ip_country.is_empty() {
            os.write_string(8, &self.ip_country)?;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(13, v, os)?;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(114)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        for v in &self.tags {
            os.write_string(17, &v)?;
        };
        if !self.raw.is_empty() {
            os.write_string(18, &self.raw)?;
        }
        if let Some(v) = self.downloaded_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
        }
        if self.ip_as_int != 0 {
            os.write_int64(23, self.ip_as_int)?;
        }
        if self.first_whois != false {
            os.write_bool(24, self.first_whois)?;
        }
        if self.new_whois != false {
            os.write_bool(25, self.new_whois)?;
        }
        if !self.reverse_lookup.is_empty() {
            os.write_string(26, &self.reverse_lookup)?;
        }
        if let Some(v) = self.gti_assessment.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(30, 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() -> EnrichedIP {
        EnrichedIP::new()
    }

    fn clear(&mut self) {
        self.whois.clear();
        self.whois_raw.clear();
        self.https_certificate.clear();
        self.jarm.clear();
        self.ip_as_owner.clear();
        self.ip_asn = 0;
        self.ip_country.clear();
        self.analysis_stats.clear();
        self.signatures.clear();
        self.tags.clear();
        self.raw.clear();
        self.downloaded_file.clear();
        self.communicating_file.clear();
        self.ip_as_int = 0;
        self.first_whois = false;
        self.new_whois = false;
        self.reverse_lookup.clear();
        self.gti_assessment.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static EnrichedIP {
        static instance: ::protobuf::rt::Lazy<EnrichedIP> = ::protobuf::rt::Lazy::new();
        instance.get(EnrichedIP::new)
    }
}

impl ::protobuf::MessageFull for EnrichedIP {
    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("EnrichedIP").unwrap()).clone()
    }
}

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

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

// @@protoc_insertion_point(message:vt.net.EnrichedDomain)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct EnrichedDomain {
    // message fields
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.raw)
    pub raw: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.root)
    pub root: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.whois)
    pub whois: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.whois_raw)
    pub whois_raw: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.https_certificate)
    pub https_certificate: ::protobuf::MessageField<SSLCertificate>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.jarm)
    pub jarm: ::std::string::String,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.dns_records)
    pub dns_records: ::std::vec::Vec<DNSRecord>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.favicon)
    pub favicon: ::protobuf::MessageField<Favicon>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.analysis_stats)
    pub analysis_stats: ::protobuf::MessageField<super::analysis::AnalysisStats>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.signatures)
    pub signatures: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.new_domain)
    pub new_domain: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.tags)
    pub tags: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.downloaded_file)
    pub downloaded_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.communicating_file)
    pub communicating_file: ::protobuf::MessageField<FileMetadata>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.first_whois)
    pub first_whois: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.new_whois)
    pub new_whois: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.first_resolution)
    pub first_resolution: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.new_resolution)
    pub new_resolution: bool,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.categories)
    pub categories: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.popularity_ranks)
    pub popularity_ranks: ::std::vec::Vec<PopularityRank>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.number_of_popularity_ranks)
    pub number_of_popularity_ranks: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.root_popularity_ranks)
    pub root_popularity_ranks: ::std::vec::Vec<PopularityRank>,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.number_of_root_popularity_ranks)
    pub number_of_root_popularity_ranks: i64,
    // @@protoc_insertion_point(field:vt.net.EnrichedDomain.gti_assessment)
    pub gti_assessment: ::protobuf::MessageField<super::hunting_gti_score::HuntingGtiScore>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.EnrichedDomain.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_simpler_field_accessor::<_, _>(
            "raw",
            |m: &EnrichedDomain| { &m.raw },
            |m: &mut EnrichedDomain| { &mut m.raw },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "root",
            |m: &EnrichedDomain| { &m.root },
            |m: &mut EnrichedDomain| { &mut m.root },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "whois",
            |m: &EnrichedDomain| { &m.whois },
            |m: &mut EnrichedDomain| { &mut m.whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "whois_raw",
            |m: &EnrichedDomain| { &m.whois_raw },
            |m: &mut EnrichedDomain| { &mut m.whois_raw },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, SSLCertificate>(
            "https_certificate",
            |m: &EnrichedDomain| { &m.https_certificate },
            |m: &mut EnrichedDomain| { &mut m.https_certificate },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "jarm",
            |m: &EnrichedDomain| { &m.jarm },
            |m: &mut EnrichedDomain| { &mut m.jarm },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "dns_records",
            |m: &EnrichedDomain| { &m.dns_records },
            |m: &mut EnrichedDomain| { &mut m.dns_records },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Favicon>(
            "favicon",
            |m: &EnrichedDomain| { &m.favicon },
            |m: &mut EnrichedDomain| { &mut m.favicon },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::analysis::AnalysisStats>(
            "analysis_stats",
            |m: &EnrichedDomain| { &m.analysis_stats },
            |m: &mut EnrichedDomain| { &mut m.analysis_stats },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "signatures",
            |m: &EnrichedDomain| { &m.signatures },
            |m: &mut EnrichedDomain| { &mut m.signatures },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_domain",
            |m: &EnrichedDomain| { &m.new_domain },
            |m: &mut EnrichedDomain| { &mut m.new_domain },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "tags",
            |m: &EnrichedDomain| { &m.tags },
            |m: &mut EnrichedDomain| { &mut m.tags },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "downloaded_file",
            |m: &EnrichedDomain| { &m.downloaded_file },
            |m: &mut EnrichedDomain| { &mut m.downloaded_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, FileMetadata>(
            "communicating_file",
            |m: &EnrichedDomain| { &m.communicating_file },
            |m: &mut EnrichedDomain| { &mut m.communicating_file },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "first_whois",
            |m: &EnrichedDomain| { &m.first_whois },
            |m: &mut EnrichedDomain| { &mut m.first_whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_whois",
            |m: &EnrichedDomain| { &m.new_whois },
            |m: &mut EnrichedDomain| { &mut m.new_whois },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "first_resolution",
            |m: &EnrichedDomain| { &m.first_resolution },
            |m: &mut EnrichedDomain| { &mut m.first_resolution },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "new_resolution",
            |m: &EnrichedDomain| { &m.new_resolution },
            |m: &mut EnrichedDomain| { &mut m.new_resolution },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_map_simpler_accessor_new::<_, _>(
            "categories",
            |m: &EnrichedDomain| { &m.categories },
            |m: &mut EnrichedDomain| { &mut m.categories },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "popularity_ranks",
            |m: &EnrichedDomain| { &m.popularity_ranks },
            |m: &mut EnrichedDomain| { &mut m.popularity_ranks },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "number_of_popularity_ranks",
            |m: &EnrichedDomain| { &m.number_of_popularity_ranks },
            |m: &mut EnrichedDomain| { &mut m.number_of_popularity_ranks },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "root_popularity_ranks",
            |m: &EnrichedDomain| { &m.root_popularity_ranks },
            |m: &mut EnrichedDomain| { &mut m.root_popularity_ranks },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "number_of_root_popularity_ranks",
            |m: &EnrichedDomain| { &m.number_of_root_popularity_ranks },
            |m: &mut EnrichedDomain| { &mut m.number_of_root_popularity_ranks },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::hunting_gti_score::HuntingGtiScore>(
            "gti_assessment",
            |m: &EnrichedDomain| { &m.gti_assessment },
            |m: &mut EnrichedDomain| { &mut m.gti_assessment },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnrichedDomain>(
            "EnrichedDomain",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                146 => {
                    self.raw = is.read_string()?;
                },
                218 => {
                    self.root = is.read_string()?;
                },
                26 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.whois.insert(key, value);
                },
                210 => {
                    self.whois_raw = is.read_string()?;
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.https_certificate)?;
                },
                42 => {
                    self.jarm = is.read_string()?;
                },
                50 => {
                    self.dns_records.push(is.read_message()?);
                },
                58 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.favicon)?;
                },
                98 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.analysis_stats)?;
                },
                106 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.signatures.insert(key, value);
                },
                128 => {
                    self.new_domain = is.read_bool()?;
                },
                138 => {
                    self.tags.push(is.read_string()?);
                },
                154 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.downloaded_file)?;
                },
                162 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.communicating_file)?;
                },
                168 => {
                    self.first_whois = is.read_bool()?;
                },
                176 => {
                    self.new_whois = is.read_bool()?;
                },
                184 => {
                    self.first_resolution = is.read_bool()?;
                },
                192 => {
                    self.new_resolution = is.read_bool()?;
                },
                226 => {
                    let len = is.read_raw_varint32()?;
                    let old_limit = is.push_limit(len as u64)?;
                    let mut key = ::std::default::Default::default();
                    let mut value = ::std::default::Default::default();
                    while let Some(tag) = is.read_raw_tag_or_eof()? {
                        match tag {
                            10 => key = is.read_string()?,
                            18 => value = is.read_string()?,
                            _ => ::protobuf::rt::skip_field_for_tag(tag, is)?,
                        };
                    }
                    is.pop_limit(old_limit);
                    self.categories.insert(key, value);
                },
                242 => {
                    self.popularity_ranks.push(is.read_message()?);
                },
                248 => {
                    self.number_of_popularity_ranks = is.read_int64()?;
                },
                258 => {
                    self.root_popularity_ranks.push(is.read_message()?);
                },
                264 => {
                    self.number_of_root_popularity_ranks = is.read_int64()?;
                },
                298 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.gti_assessment)?;
                },
                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 !self.raw.is_empty() {
            my_size += ::protobuf::rt::string_size(18, &self.raw);
        }
        if !self.root.is_empty() {
            my_size += ::protobuf::rt::string_size(27, &self.root);
        }
        for (k, v) in &self.whois {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if !self.whois_raw.is_empty() {
            my_size += ::protobuf::rt::string_size(26, &self.whois_raw);
        }
        if let Some(v) = self.https_certificate.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.jarm.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.jarm);
        }
        for value in &self.dns_records {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.favicon.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        if self.new_domain != false {
            my_size += 2 + 1;
        }
        for value in &self.tags {
            my_size += ::protobuf::rt::string_size(17, &value);
        };
        if let Some(v) = self.downloaded_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if self.first_whois != false {
            my_size += 2 + 1;
        }
        if self.new_whois != false {
            my_size += 2 + 1;
        }
        if self.first_resolution != false {
            my_size += 2 + 1;
        }
        if self.new_resolution != false {
            my_size += 2 + 1;
        }
        for (k, v) in &self.categories {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(entry_size) + entry_size
        };
        for value in &self.popularity_ranks {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.number_of_popularity_ranks != 0 {
            my_size += ::protobuf::rt::int64_size(31, self.number_of_popularity_ranks);
        }
        for value in &self.root_popularity_ranks {
            let len = value.compute_size();
            my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if self.number_of_root_popularity_ranks != 0 {
            my_size += ::protobuf::rt::int64_size(33, self.number_of_root_popularity_ranks);
        }
        if let Some(v) = self.gti_assessment.as_ref() {
            let len = v.compute_size();
            my_size += 2 + ::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 !self.raw.is_empty() {
            os.write_string(18, &self.raw)?;
        }
        if !self.root.is_empty() {
            os.write_string(27, &self.root)?;
        }
        for (k, v) in &self.whois {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(26)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if !self.whois_raw.is_empty() {
            os.write_string(26, &self.whois_raw)?;
        }
        if let Some(v) = self.https_certificate.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if !self.jarm.is_empty() {
            os.write_string(5, &self.jarm)?;
        }
        for v in &self.dns_records {
            ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?;
        };
        if let Some(v) = self.favicon.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(7, v, os)?;
        }
        if let Some(v) = self.analysis_stats.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(12, v, os)?;
        }
        for (k, v) in &self.signatures {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(106)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        if self.new_domain != false {
            os.write_bool(16, self.new_domain)?;
        }
        for v in &self.tags {
            os.write_string(17, &v)?;
        };
        if let Some(v) = self.downloaded_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?;
        }
        if let Some(v) = self.communicating_file.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(20, v, os)?;
        }
        if self.first_whois != false {
            os.write_bool(21, self.first_whois)?;
        }
        if self.new_whois != false {
            os.write_bool(22, self.new_whois)?;
        }
        if self.first_resolution != false {
            os.write_bool(23, self.first_resolution)?;
        }
        if self.new_resolution != false {
            os.write_bool(24, self.new_resolution)?;
        }
        for (k, v) in &self.categories {
            let mut entry_size = 0;
            entry_size += ::protobuf::rt::string_size(1, &k);
            entry_size += ::protobuf::rt::string_size(2, &v);
            os.write_raw_varint32(226)?; // Tag.
            os.write_raw_varint32(entry_size as u32)?;
            os.write_string(1, &k)?;
            os.write_string(2, &v)?;
        };
        for v in &self.popularity_ranks {
            ::protobuf::rt::write_message_field_with_cached_size(30, v, os)?;
        };
        if self.number_of_popularity_ranks != 0 {
            os.write_int64(31, self.number_of_popularity_ranks)?;
        }
        for v in &self.root_popularity_ranks {
            ::protobuf::rt::write_message_field_with_cached_size(32, v, os)?;
        };
        if self.number_of_root_popularity_ranks != 0 {
            os.write_int64(33, self.number_of_root_popularity_ranks)?;
        }
        if let Some(v) = self.gti_assessment.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(37, 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() -> EnrichedDomain {
        EnrichedDomain::new()
    }

    fn clear(&mut self) {
        self.raw.clear();
        self.root.clear();
        self.whois.clear();
        self.whois_raw.clear();
        self.https_certificate.clear();
        self.jarm.clear();
        self.dns_records.clear();
        self.favicon.clear();
        self.analysis_stats.clear();
        self.signatures.clear();
        self.new_domain = false;
        self.tags.clear();
        self.downloaded_file.clear();
        self.communicating_file.clear();
        self.first_whois = false;
        self.new_whois = false;
        self.first_resolution = false;
        self.new_resolution = false;
        self.categories.clear();
        self.popularity_ranks.clear();
        self.number_of_popularity_ranks = 0;
        self.root_popularity_ranks.clear();
        self.number_of_root_popularity_ranks = 0;
        self.gti_assessment.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static EnrichedDomain {
        static instance: ::protobuf::rt::Lazy<EnrichedDomain> = ::protobuf::rt::Lazy::new();
        instance.get(EnrichedDomain::new)
    }
}

impl ::protobuf::MessageFull for EnrichedDomain {
    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("EnrichedDomain").unwrap()).clone()
    }
}

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

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

/// Nested message and enums of message `EnrichedDomain`
pub mod enriched_domain {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:vt.net.EnrichedDomain.Permutation)
    pub enum Permutation {
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.ALL)
        ALL = 0,
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.TYPO)
        TYPO = 1,
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.HOMOGLYPH)
        HOMOGLYPH = 2,
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.HYPHENATION)
        HYPHENATION = 3,
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.SUBDOMAIN)
        SUBDOMAIN = 4,
        // @@protoc_insertion_point(enum_value:vt.net.EnrichedDomain.Permutation.BITSQUATTING)
        BITSQUATTING = 5,
    }

    impl ::protobuf::Enum for Permutation {
        const NAME: &'static str = "Permutation";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<Permutation> {
            match value {
                0 => ::std::option::Option::Some(Permutation::ALL),
                1 => ::std::option::Option::Some(Permutation::TYPO),
                2 => ::std::option::Option::Some(Permutation::HOMOGLYPH),
                3 => ::std::option::Option::Some(Permutation::HYPHENATION),
                4 => ::std::option::Option::Some(Permutation::SUBDOMAIN),
                5 => ::std::option::Option::Some(Permutation::BITSQUATTING),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<Permutation> {
            match str {
                "ALL" => ::std::option::Option::Some(Permutation::ALL),
                "TYPO" => ::std::option::Option::Some(Permutation::TYPO),
                "HOMOGLYPH" => ::std::option::Option::Some(Permutation::HOMOGLYPH),
                "HYPHENATION" => ::std::option::Option::Some(Permutation::HYPHENATION),
                "SUBDOMAIN" => ::std::option::Option::Some(Permutation::SUBDOMAIN),
                "BITSQUATTING" => ::std::option::Option::Some(Permutation::BITSQUATTING),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [Permutation] = &[
            Permutation::ALL,
            Permutation::TYPO,
            Permutation::HOMOGLYPH,
            Permutation::HYPHENATION,
            Permutation::SUBDOMAIN,
            Permutation::BITSQUATTING,
        ];
    }

    impl ::protobuf::EnumFull for Permutation {
        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("EnrichedDomain.Permutation").unwrap()).clone()
        }

        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
            let index = *self as usize;
            Self::enum_descriptor().value_by_index(index)
        }
    }

    impl ::std::default::Default for Permutation {
        fn default() -> Self {
            Permutation::ALL
        }
    }

    impl Permutation {
        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Permutation>("EnrichedDomain.Permutation")
        }
    }
}

// @@protoc_insertion_point(message:vt.net.EnrichedNetloc)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct EnrichedNetloc {
    // message fields
    // @@protoc_insertion_point(field:vt.net.EnrichedNetloc.url)
    pub url: ::protobuf::MessageField<EnrichedURL>,
    // @@protoc_insertion_point(field:vt.net.EnrichedNetloc.ip)
    pub ip: ::protobuf::MessageField<EnrichedIP>,
    // @@protoc_insertion_point(field:vt.net.EnrichedNetloc.domain)
    pub domain: ::protobuf::MessageField<EnrichedDomain>,
    // special fields
    // @@protoc_insertion_point(special_field:vt.net.EnrichedNetloc.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

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

    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_message_field_accessor::<_, EnrichedURL>(
            "url",
            |m: &EnrichedNetloc| { &m.url },
            |m: &mut EnrichedNetloc| { &mut m.url },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, EnrichedIP>(
            "ip",
            |m: &EnrichedNetloc| { &m.ip },
            |m: &mut EnrichedNetloc| { &mut m.ip },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, EnrichedDomain>(
            "domain",
            |m: &EnrichedNetloc| { &m.domain },
            |m: &mut EnrichedNetloc| { &mut m.domain },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EnrichedNetloc>(
            "EnrichedNetloc",
            fields,
            oneofs,
        )
    }
}

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

    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 {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.url)?;
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.ip)?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.domain)?;
                },
                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.url.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.ip.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.domain.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.url.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        if let Some(v) = self.ip.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if let Some(v) = self.domain.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() -> EnrichedNetloc {
        EnrichedNetloc::new()
    }

    fn clear(&mut self) {
        self.url.clear();
        self.ip.clear();
        self.domain.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static EnrichedNetloc {
        static instance: EnrichedNetloc = EnrichedNetloc {
            url: ::protobuf::MessageField::none(),
            ip: ::protobuf::MessageField::none(),
            domain: ::protobuf::MessageField::none(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for EnrichedNetloc {
    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("EnrichedNetloc").unwrap()).clone()
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x0evt/vtnet.proto\x12\x06vt.net\x1a\x11vt/analysis.proto\x1a\x12vt/fi\
    letypes.proto\x1a\x1avt/hunting_gti_score.proto\x1a\x10vt/sandbox.proto\
    \x1a\x12vt/submitter.proto\x1a\nyara.proto\"\xcb\x01\n\x07Subject\x12\
    \x1f\n\x0bcommon_name\x18\x01\x20\x01(\tR\ncommonName\x12\x18\n\x07count\
    ry\x18\x02\x20\x01(\tR\x07country\x12\"\n\x0corganization\x18\x03\x20\
    \x01(\tR\x0corganization\x12/\n\x13organizational_unit\x18\x04\x20\x01(\
    \tR\x12organizationalUnit\x12\x1a\n\x08locality\x18\x05\x20\x01(\tR\x08l\
    ocality\x12\x14\n\x05state\x18\x06\x20\x01(\tR\x05state\"F\n\x08Validity\
    \x12\x1b\n\tnot_after\x18\x01\x20\x01(\x03R\x08notAfter\x12\x1d\n\nnot_b\
    efore\x18\x02\x20\x01(\x03R\tnotBefore\"\xaf\x02\n\x0eSSLCertificate\x12\
    \x1e\n\nthumbprint\x18\x01\x20\x01(\tR\nthumbprint\x12)\n\x07subject\x18\
    \x02\x20\x01(\x0b2\x0f.vt.net.SubjectR\x07subject\x12,\n\x08validity\x18\
    \x03\x20\x01(\x0b2\x10.vt.net.ValidityR\x08validity\x128\n\x18subject_al\
    ternative_name\x18\x04\x20\x03(\tR\x16subjectAlternativeName\x12\x1c\n\t\
    signature\x18\x05\x20\x01(\tR\tsignature\x12#\n\rserial_number\x18\x06\
    \x20\x01(\tR\x0cserialNumber\x12'\n\x06issuer\x18\x07\x20\x01(\x0b2\x0f.\
    vt.net.SubjectR\x06issuer\"?\n\x07Tracker\x12\x12\n\x04name\x18\x01\x20\
    \x01(\tR\x04name\x12\x0e\n\x02id\x18\x02\x20\x01(\tR\x02id\x12\x10\n\x03\
    url\x18\x03\x20\x01(\tR\x03url\"\xa6\x02\n\tDNSRecord\x12\x12\n\x04type\
    \x18\x02\x20\x01(\tR\x04type\x12\x1b\n\tdns_class\x18\x03\x20\x01(\tR\
    \x08dnsClass\x12\x10\n\x03ttl\x18\x04\x20\x01(\x03R\x03ttl\x12\x14\n\x05\
    mname\x18\x05\x20\x01(\tR\x05mname\x12\x14\n\x05rname\x18\x06\x20\x01(\t\
    R\x05rname\x12\x1a\n\x08priority\x18\x07\x20\x01(\x03R\x08priority\x12\
    \x16\n\x06serial\x18\x08\x20\x01(\x03R\x06serial\x12\x14\n\x05retry\x18\
    \t\x20\x01(\x03R\x05retry\x12\x18\n\x07refresh\x18\n\x20\x01(\x03R\x07re\
    fresh\x12\x16\n\x06expire\x18\x0b\x20\x01(\x03R\x06expire\x12\x18\n\x07m\
    inimum\x18\x0c\x20\x01(\x03R\x07minimum\x12\x14\n\x05value\x18\r\x20\x01\
    (\tR\x05value\"@\n\x07Favicon\x12\x1f\n\x07raw_md5\x18\x01\x20\x01(\tR\
    \x06rawMd5B\x06\x82\x93\x19\x02\x20\x01\x12\x14\n\x05dhash\x18\x02\x20\
    \x01(\tR\x05dhash\"4\n\x08KeyValue\x12\x10\n\x03key\x18\x01\x20\x01(\tR\
    \x03key\x12\x16\n\x06values\x18\x02\x20\x03(\tR\x06values\"\xb0\x03\n\
    \x0cFileMetadata\x12\x1e\n\x06sha256\x18\x01\x20\x01(\tR\x06sha256B\x06\
    \x82\x93\x19\x02\x20\x01\x12\x1c\n\nnew_for_vt\x18\x03\x20\x01(\x08R\x08\
    newForVt\x12A\n\x0eanalysis_stats\x18\x05\x20\x01(\x0b2\x1a.vt.analysis.\
    AnalysisStatsR\ranalysisStats\x126\n\tfile_type\x18\x06\x20\x01(\x0e2\
    \x19.vt.fileanalysis.FileTypeR\x08fileType\x12\x1e\n\x0bnew_for_url\x18\
    \x07\x20\x01(\x08R\tnewForUrl\x12\x1c\n\nnew_for_ip\x18\x08\x20\x01(\x08\
    R\x08newForIp\x12$\n\x0enew_for_domain\x18\t\x20\x01(\x08R\x0cnewForDoma\
    in\x12D\n\nsignatures\x18\n\x20\x03(\x0b2$.vt.net.FileMetadata.Signature\
    sEntryR\nsignatures\x1a=\n\x0fSignaturesEntry\x12\x10\n\x03key\x18\x01\
    \x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x02\
    8\x01\"\xde\x02\n\x14ResourceFileMetadata\x12\x1e\n\x06sha256\x18\x01\
    \x20\x01(\tR\x06sha256B\x06\x82\x93\x19\x02\x20\x01\x12A\n\x0eanalysis_s\
    tats\x18\x02\x20\x01(\x0b2\x1a.vt.analysis.AnalysisStatsR\ranalysisStats\
    \x126\n\tfile_type\x18\x03\x20\x01(\x0e2\x19.vt.fileanalysis.FileTypeR\
    \x08fileType\x12\x1e\n\x0bnew_for_url\x18\x04\x20\x01(\x08R\tnewForUrl\
    \x12L\n\nsignatures\x18\x05\x20\x03(\x0b2,.vt.net.ResourceFileMetadata.S\
    ignaturesEntryR\nsignatures\x1a=\n\x0fSignaturesEntry\x12\x10\n\x03key\
    \x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05va\
    lue:\x028\x01\"g\n\x0ePopularityRank\x12\x1a\n\x08position\x18\x01\x20\
    \x01(\x03R\x08position\x12%\n\x0eingestion_time\x18\x02\x20\x01(\x03R\ri\
    ngestionTime\x12\x12\n\x04rank\x18\x03\x20\x01(\tR\x04rank\"\xc4\r\n\x0b\
    EnrichedURL\x12\x12\n\x04port\x18\x03\x20\x01(\x03R\x04port\x12+\n\x08tr\
    ackers\x18\x04\x20\x03(\x0b2\x0f.vt.net.TrackerR\x08trackers\x12S\n\x10r\
    esponse_headers\x18\x05\x20\x03(\x0b2(.vt.net.EnrichedURL.ResponseHeader\
    sEntryR\x0fresponseHeaders\x12;\n\x1anumber_of_response_headers\x18!\x20\
    \x01(\x03R\x17numberOfResponseHeaders\x12#\n\rresponse_code\x18\x06\x20\
    \x01(\x03R\x0cresponseCode\x12:\n\x07cookies\x18\x07\x20\x03(\x0b2\x20.v\
    t.net.EnrichedURL.CookiesEntryR\x07cookies\x12)\n\x07favicon\x18\x08\x20\
    \x01(\x0b2\x0f.vt.net.FaviconR\x07favicon\x12%\n\x0eoutgoing_links\x18\t\
    \x20\x03(\tR\routgoingLinks\x12\x1c\n\tredirects\x18\n\x20\x03(\tR\tredi\
    rects\x12\x1d\n\nhtml_title\x18\x0b\x20\x01(\tR\thtmlTitle\x126\n\x0ehtm\
    l_meta_tags\x18\x0c\x20\x03(\x0b2\x10.vt.net.KeyValueR\x0chtmlMetaTags\
    \x12\x17\n\x07new_url\x18\x11\x20\x01(\x08R\x06newUrl\x12A\n\x0eanalysis\
    _stats\x18\x12\x20\x01(\x0b2\x1a.vt.analysis.AnalysisStatsR\ranalysisSta\
    ts\x122\n\x15first_submission_date\x18\x13\x20\x01(\x03R\x13firstSubmiss\
    ionDate\x12C\n\nsignatures\x18\x14\x20\x03(\x0b2#.vt.net.EnrichedURL.Sig\
    naturesEntryR\nsignatures\x125\n\tsubmitter\x18\x15\x20\x01(\x0b2\x17.vt\
    .submitter.SubmitterR\tsubmitter\x12\x12\n\x04tags\x18\x18\x20\x03(\tR\
    \x04tags\x12\x14\n\x05query\x18\"\x20\x01(\tR\x05query\x127\n\x06params\
    \x18\x19\x20\x03(\x0b2\x1f.vt.net.EnrichedURL.ParamsEntryR\x06params\x12\
    \x12\n\x04path\x18\x1a\x20\x01(\tR\x04path\x12\x1a\n\x08hostname\x18\x1b\
    \x20\x01(\tR\x08hostname\x12\x10\n\x03raw\x18\x1c\x20\x01(\tR\x03raw\x12\
    =\n\x0fdownloaded_file\x18\x1d\x20\x01(\x0b2\x14.vt.net.FileMetadataR\
    \x0edownloadedFile\x12C\n\x12communicating_file\x18\x1e\x20\x01(\x0b2\
    \x14.vt.net.FileMetadataR\x11communicatingFile\x12K\n\x12embedded_resour\
    ces\x18\x1f\x20\x03(\x0b2\x1c.vt.net.ResourceFileMetadataR\x11embeddedRe\
    sources\x12C\n\ncategories\x18#\x20\x03(\x0b2#.vt.net.EnrichedURL.Catego\
    riesEntryR\ncategories\x12\xae\x01\n\x0egti_assessment\x18'\x20\x01(\x0b\
    2%.vt.hunting_gti_score.HuntingGtiScoreR\rgtiAssessmentB`\x82\x93\x19\\\
    \x1aZ\n(unknown\x20field\x20or\x20method\x20`gti_assessment`\x12\"this\
    \x20field\x20or\x20method\x20doesn't\x20exist\x1a\x03gti\x1a\x05staff\
    \x1aB\n\x14ResponseHeadersEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03\
    key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\x1a:\n\x0c\
    CookiesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05va\
    lue\x18\x02\x20\x01(\tR\x05value:\x028\x01\x1a=\n\x0fSignaturesEntry\x12\
    \x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\
    \x01(\tR\x05value:\x028\x01\x1a9\n\x0bParamsEntry\x12\x10\n\x03key\x18\
    \x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\
    \x028\x01\x1a=\n\x0fCategoriesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\
    \x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01:\t\x8a\
    \x93\x19\x05\n\x03URL\"\xf1\t\n\nEnrichedIP\x123\n\x05whois\x18\x03\x20\
    \x03(\x0b2\x1d.vt.net.EnrichedIP.WhoisEntryR\x05whois\x12\x1b\n\twhois_r\
    aw\x18\x16\x20\x01(\tR\x08whoisRaw\x12C\n\x11https_certificate\x18\x04\
    \x20\x01(\x0b2\x16.vt.net.SSLCertificateR\x10httpsCertificate\x12\x12\n\
    \x04jarm\x18\x05\x20\x01(\tR\x04jarm\x12\x1e\n\x0bip_as_owner\x18\x06\
    \x20\x01(\tR\tipAsOwner\x12\x15\n\x06ip_asn\x18\x07\x20\x01(\x03R\x05ipA\
    sn\x12\x1d\n\nip_country\x18\x08\x20\x01(\tR\tipCountry\x12A\n\x0eanalys\
    is_stats\x18\r\x20\x01(\x0b2\x1a.vt.analysis.AnalysisStatsR\ranalysisSta\
    ts\x12B\n\nsignatures\x18\x0e\x20\x03(\x0b2\".vt.net.EnrichedIP.Signatur\
    esEntryR\nsignatures\x12\x12\n\x04tags\x18\x11\x20\x03(\tR\x04tags\x12\
    \x10\n\x03raw\x18\x12\x20\x01(\tR\x03raw\x12=\n\x0fdownloaded_file\x18\
    \x13\x20\x01(\x0b2\x14.vt.net.FileMetadataR\x0edownloadedFile\x12C\n\x12\
    communicating_file\x18\x14\x20\x01(\x0b2\x14.vt.net.FileMetadataR\x11com\
    municatingFile\x12\x1a\n\tip_as_int\x18\x17\x20\x01(\x03R\x07ipAsInt\x12\
    \x9e\x01\n\x0bfirst_whois\x18\x18\x20\x01(\x08R\nfirstWhoisB}\x82\x93\
    \x19y\x1aw\nCvt.net.ip.first_whois\x20is\x20supported\x20in\x20rulesets\
    \x20matching\x20against\x20IPs\x12$this\x20field\x20is\x20supported\x20f\
    or\x20IPs\x20only\x1a\nip_address\x12\x98\x01\n\tnew_whois\x18\x19\x20\
    \x01(\x08R\x08newWhoisB{\x82\x93\x19w\x1au\nAvt.net.ip.new_whois\x20is\
    \x20supported\x20in\x20rulesets\x20matching\x20against\x20IPs\x12$this\
    \x20field\x20is\x20supported\x20for\x20IPs\x20only\x1a\nip_address\x12%\
    \n\x0ereverse_lookup\x18\x1a\x20\x01(\tR\rreverseLookup\x12\xae\x01\n\
    \x0egti_assessment\x18\x1e\x20\x01(\x0b2%.vt.hunting_gti_score.HuntingGt\
    iScoreR\rgtiAssessmentB`\x82\x93\x19\\\x1aZ\n(unknown\x20field\x20or\x20\
    method\x20`gti_assessment`\x12\"this\x20field\x20or\x20method\x20doesn't\
    \x20exist\x1a\x03gti\x1a\x05staff\x1a8\n\nWhoisEntry\x12\x10\n\x03key\
    \x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05va\
    lue:\x028\x01\x1a=\n\x0fSignaturesEntry\x12\x10\n\x03key\x18\x01\x20\x01\
    (\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01:\
    \x08\x8a\x93\x19\x04\n\x02IP\"\xfb\x0c\n\x0eEnrichedDomain\x12\x10\n\x03\
    raw\x18\x12\x20\x01(\tR\x03raw\x12\x12\n\x04root\x18\x1b\x20\x01(\tR\x04\
    root\x127\n\x05whois\x18\x03\x20\x03(\x0b2!.vt.net.EnrichedDomain.WhoisE\
    ntryR\x05whois\x12\x1b\n\twhois_raw\x18\x1a\x20\x01(\tR\x08whoisRaw\x12C\
    \n\x11https_certificate\x18\x04\x20\x01(\x0b2\x16.vt.net.SSLCertificateR\
    \x10httpsCertificate\x12\x12\n\x04jarm\x18\x05\x20\x01(\tR\x04jarm\x122\
    \n\x0bdns_records\x18\x06\x20\x03(\x0b2\x11.vt.net.DNSRecordR\ndnsRecord\
    s\x12)\n\x07favicon\x18\x07\x20\x01(\x0b2\x0f.vt.net.FaviconR\x07favicon\
    \x12A\n\x0eanalysis_stats\x18\x0c\x20\x01(\x0b2\x1a.vt.analysis.Analysis\
    StatsR\ranalysisStats\x12F\n\nsignatures\x18\r\x20\x03(\x0b2&.vt.net.Enr\
    ichedDomain.SignaturesEntryR\nsignatures\x12\x1d\n\nnew_domain\x18\x10\
    \x20\x01(\x08R\tnewDomain\x12\x12\n\x04tags\x18\x11\x20\x03(\tR\x04tags\
    \x12=\n\x0fdownloaded_file\x18\x13\x20\x01(\x0b2\x14.vt.net.FileMetadata\
    R\x0edownloadedFile\x12C\n\x12communicating_file\x18\x14\x20\x01(\x0b2\
    \x14.vt.net.FileMetadataR\x11communicatingFile\x12\x1f\n\x0bfirst_whois\
    \x18\x15\x20\x01(\x08R\nfirstWhois\x12\x1b\n\tnew_whois\x18\x16\x20\x01(\
    \x08R\x08newWhois\x12)\n\x10first_resolution\x18\x17\x20\x01(\x08R\x0ffi\
    rstResolution\x12%\n\x0enew_resolution\x18\x18\x20\x01(\x08R\rnewResolut\
    ion\x12F\n\ncategories\x18\x1c\x20\x03(\x0b2&.vt.net.EnrichedDomain.Cate\
    goriesEntryR\ncategories\x12A\n\x10popularity_ranks\x18\x1e\x20\x03(\x0b\
    2\x16.vt.net.PopularityRankR\x0fpopularityRanks\x12;\n\x1anumber_of_popu\
    larity_ranks\x18\x1f\x20\x01(\x03R\x17numberOfPopularityRanks\x12J\n\x15\
    root_popularity_ranks\x18\x20\x20\x03(\x0b2\x16.vt.net.PopularityRankR\
    \x13rootPopularityRanks\x12D\n\x1fnumber_of_root_popularity_ranks\x18!\
    \x20\x01(\x03R\x1bnumberOfRootPopularityRanks\x12\xae\x01\n\x0egti_asses\
    sment\x18%\x20\x01(\x0b2%.vt.hunting_gti_score.HuntingGtiScoreR\rgtiAsse\
    ssmentB`\x82\x93\x19\\\x1aZ\n(unknown\x20field\x20or\x20method\x20`gti_a\
    ssessment`\x12\"this\x20field\x20or\x20method\x20doesn't\x20exist\x1a\
    \x03gti\x1a\x05staff\x1a8\n\nWhoisEntry\x12\x10\n\x03key\x18\x01\x20\x01\
    (\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\
    \x1a=\n\x0fSignaturesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\
    \x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\x028\x01\x1a=\n\x0fCat\
    egoriesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05va\
    lue\x18\x02\x20\x01(\tR\x05value:\x028\x01\"\x91\x01\n\x0bPermutation\
    \x12\x0f\n\x03ALL\x10\0\x1a\x06\x9a\x93\x19\x02\x08\x1f\x12\x10\n\x04TYP\
    O\x10\x01\x1a\x06\x9a\x93\x19\x02\x08\x01\x12\x15\n\tHOMOGLYPH\x10\x02\
    \x1a\x06\x9a\x93\x19\x02\x08\x02\x12\x17\n\x0bHYPHENATION\x10\x03\x1a\
    \x06\x9a\x93\x19\x02\x08\x04\x12\x15\n\tSUBDOMAIN\x10\x04\x1a\x06\x9a\
    \x93\x19\x02\x08\x08\x12\x18\n\x0cBITSQUATTING\x10\x05\x1a\x06\x9a\x93\
    \x19\x02\x08\x10:\x0c\x8a\x93\x19\x08\n\x06Domain\"\xd8\x04\n\x0eEnriche\
    dNetloc\x12\x9f\x01\n\x03url\x18\x01\x20\x01(\x0b2\x13.vt.net.EnrichedUR\
    LR\x03urlBx\x82\x93\x19t\x1ar\n>vt.net.url\x20is\x20supported\x20only\
    \x20in\x20rulesets\x20matching\x20against\x20URLs\x12%this\x20field\x20i\
    s\x20supported\x20for\x20URLs\x20only\x1a\x03url\x1a\x04file\x12\xd3\x01\
    \n\x02ip\x18\x02\x20\x01(\x0b2\x12.vt.net.EnrichedIPR\x02ipB\xae\x01\x82\
    \x93\x19\xa9\x01\x1a\xa6\x01\nMvt.net.ip\x20is\x20supported\x20only\x20i\
    n\x20rulesets\x20matching\x20against\x20URLs,\x20domains\x20or\x20IPs\
    \x126this\x20field\x20is\x20supported\x20for\x20URLs,\x20domains\x20and\
    \x20IPs\x20only\x1a\x03url\x1a\x06domain\x1a\nip_address\x1a\x04file\x12\
    \xcd\x01\n\x06domain\x18\x03\x20\x01(\x0b2\x16.vt.net.EnrichedDomainR\
    \x06domainB\x9c\x01\x82\x93\x19\x97\x01\x1a\x94\x01\nLvt.net.domain\x20i\
    s\x20supported\x20only\x20in\x20rulesets\x20matching\x20against\x20URLs\
    \x20or\x20domains\x121this\x20field\x20is\x20supported\x20for\x20URLs\
    \x20and\x20domains\x20only\x1a\x03url\x1a\x06domain\x1a\x04fileb\x06prot\
    o3\
";

/// `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(6);
            deps.push(super::analysis::file_descriptor().clone());
            deps.push(super::filetypes::file_descriptor().clone());
            deps.push(super::hunting_gti_score::file_descriptor().clone());
            deps.push(super::sandbox::file_descriptor().clone());
            deps.push(super::submitter::file_descriptor().clone());
            deps.push(super::yara::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(14);
            messages.push(Subject::generated_message_descriptor_data());
            messages.push(Validity::generated_message_descriptor_data());
            messages.push(SSLCertificate::generated_message_descriptor_data());
            messages.push(Tracker::generated_message_descriptor_data());
            messages.push(DNSRecord::generated_message_descriptor_data());
            messages.push(Favicon::generated_message_descriptor_data());
            messages.push(KeyValue::generated_message_descriptor_data());
            messages.push(FileMetadata::generated_message_descriptor_data());
            messages.push(ResourceFileMetadata::generated_message_descriptor_data());
            messages.push(PopularityRank::generated_message_descriptor_data());
            messages.push(EnrichedURL::generated_message_descriptor_data());
            messages.push(EnrichedIP::generated_message_descriptor_data());
            messages.push(EnrichedDomain::generated_message_descriptor_data());
            messages.push(EnrichedNetloc::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(1);
            enums.push(enriched_domain::Permutation::generated_enum_descriptor_data());
            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
                file_descriptor_proto(),
                deps,
                messages,
                enums,
            )
        });
        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
    })
}