google-backstory 1.1.0

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

#[doc(hidden)]
impl serde::ser::Serialize for super::Collection {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !wkt::internal::is_default(&self.id_namespace) {
            state.serialize_entry("idNamespace", &self.id_namespace)?;
        }
        if self.created_time.is_some() {
            state.serialize_entry("createdTime", &self.created_time)?;
        }
        if self.last_updated_time.is_some() {
            state.serialize_entry("lastUpdatedTime", &self.last_updated_time)?;
        }
        if self.time_window.is_some() {
            state.serialize_entry("timeWindow", &self.time_window)?;
        }
        if !self.collection_elements.is_empty() {
            state.serialize_entry("collectionElements", &self.collection_elements)?;
        }
        if !self.detection.is_empty() {
            state.serialize_entry("detection", &self.detection)?;
        }
        if self.detection_time.is_some() {
            state.serialize_entry("detectionTime", &self.detection_time)?;
        }
        if self.investigation.is_some() {
            state.serialize_entry("investigation", &self.investigation)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if self.response_platform_info.is_some() {
            state.serialize_entry("responsePlatformInfo", &self.response_platform_info)?;
        }
        if !self.case_name.is_empty() {
            state.serialize_entry("caseName", &self.case_name)?;
        }
        if !wkt::internal::is_default(&self.soar_alert) {
            state.serialize_entry("soarAlert", &self.soar_alert)?;
        }
        if self.soar_alert_metadata.is_some() {
            state.serialize_entry("soarAlertMetadata", &self.soar_alert_metadata)?;
        }
        if !self.data_access_scope.is_empty() {
            state.serialize_entry("dataAccessScope", &self.data_access_scope)?;
        }
        if !self.detection_timing_details.is_empty() {
            state.serialize_entry("detectionTimingDetails", &self.detection_timing_details)?;
        }
        if self.latency_metrics.is_some() {
            state.serialize_entry("latencyMetrics", &self.latency_metrics)?;
        }
        if !wkt::internal::is_default(&self.rule_run_frequency) {
            state.serialize_entry("ruleRunFrequency", &self.rule_run_frequency)?;
        }
        if !wkt::internal::is_default(&self.simulated_event_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("simulatedEventCount", &__With(&self.simulated_event_count))?;
        }
        if !self.simulated_event_names.is_empty() {
            state.serialize_entry("simulatedEventNames", &self.simulated_event_names)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::EntityGraphEnrichment {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.data_table.is_empty() {
            state.serialize_entry("dataTable", &self.data_table)?;
        }
        if !wkt::internal::is_default(&self.enrichment_type) {
            state.serialize_entry("enrichmentType", &self.enrichment_type)?;
        }
        if self.overridden_entity.is_some() {
            state.serialize_entry("overriddenEntity", &self.overridden_entity)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::DataTableRowInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.data_table.is_empty() {
            state.serialize_entry("dataTable", &self.data_table)?;
        }
        if self.row.is_some() {
            state.serialize_entry("row", &self.row)?;
        }
        if !self.row_id.is_empty() {
            state.serialize_entry("rowId", &self.row_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::LatencyMetrics {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.oldest_ingestion_time.is_some() {
            state.serialize_entry("oldestIngestionTime", &self.oldest_ingestion_time)?;
        }
        if self.newest_ingestion_time.is_some() {
            state.serialize_entry("newestIngestionTime", &self.newest_ingestion_time)?;
        }
        if self.oldest_event_time.is_some() {
            state.serialize_entry("oldestEventTime", &self.oldest_event_time)?;
        }
        if self.newest_event_time.is_some() {
            state.serialize_entry("newestEventTime", &self.newest_event_time)?;
        }
        if self.ingestion_latency.is_some() {
            state.serialize_entry("ingestionLatency", &self.ingestion_latency)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Reference {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.event.is_some() {
            state.serialize_entry("event", &self.event)?;
        }
        if self.entity.is_some() {
            state.serialize_entry("entity", &self.entity)?;
        }
        if !self.joined_data_table_rows.is_empty() {
            state.serialize_entry("joinedDataTableRows", &self.joined_data_table_rows)?;
        }
        if self.graph_enrichment.is_some() {
            state.serialize_entry("graphEnrichment", &self.graph_enrichment)?;
        }
        if self.id.is_some() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.log_batch_token.is_empty() {
            state.serialize_entry("logBatchToken", &self.log_batch_token)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Element {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.association.is_some() {
            state.serialize_entry("association", &self.association)?;
        }
        if !self.references.is_empty() {
            state.serialize_entry("references", &self.references)?;
        }
        if !self.label.is_empty() {
            state.serialize_entry("label", &self.label)?;
        }
        if !wkt::internal::is_default(&self.references_sampled) {
            state.serialize_entry("referencesSampled", &self.references_sampled)?;
        }
        if self.latency_metrics.is_some() {
            state.serialize_entry("latencyMetrics", &self.latency_metrics)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ResponsePlatformInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.alert_id.is_empty() {
            state.serialize_entry("alertId", &self.alert_id)?;
        }
        if !wkt::internal::is_default(&self.response_platform_type) {
            state.serialize_entry("responsePlatformType", &self.response_platform_type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SoarAlertMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.alert_id.is_empty() {
            state.serialize_entry("alertId", &self.alert_id)?;
        }
        if !self.source_rule.is_empty() {
            state.serialize_entry("sourceRule", &self.source_rule)?;
        }
        if !self.vendor.is_empty() {
            state.serialize_entry("vendor", &self.vendor)?;
        }
        if !self.source_system.is_empty() {
            state.serialize_entry("sourceSystem", &self.source_system)?;
        }
        if !self.product.is_empty() {
            state.serialize_entry("product", &self.product)?;
        }
        if !self.source_system_ticket_id.is_empty() {
            state.serialize_entry("sourceSystemTicketId", &self.source_system_ticket_id)?;
        }
        if !self.source_system_uri.is_empty() {
            state.serialize_entry("sourceSystemUri", &self.source_system_uri)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::DataAccessIngestionLabel {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.key.is_empty() {
            state.serialize_entry("key", &self.key)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::DataAccessLabels {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.log_types.is_empty() {
            state.serialize_entry("logTypes", &self.log_types)?;
        }
        if !self.ingestion_labels.is_empty() {
            state.serialize_entry("ingestionLabels", &self.ingestion_labels)?;
        }
        if !self.namespaces.is_empty() {
            state.serialize_entry("namespaces", &self.namespaces)?;
        }
        if !self.custom_labels.is_empty() {
            state.serialize_entry("customLabels", &self.custom_labels)?;
        }
        if !self.ingestion_kv_labels.is_empty() {
            state.serialize_entry("ingestionKvLabels", &self.ingestion_kv_labels)?;
        }
        if !wkt::internal::is_default(&self.allow_scoped_access) {
            state.serialize_entry("allowScopedAccess", &self.allow_scoped_access)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::EntityMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.product_entity_id.is_empty() {
            state.serialize_entry("productEntityId", &self.product_entity_id)?;
        }
        if self.collected_timestamp.is_some() {
            state.serialize_entry("collectedTimestamp", &self.collected_timestamp)?;
        }
        if self.creation_timestamp.is_some() {
            state.serialize_entry("creationTimestamp", &self.creation_timestamp)?;
        }
        if self.interval.is_some() {
            state.serialize_entry("interval", &self.interval)?;
        }
        if !self.vendor_name.is_empty() {
            state.serialize_entry("vendorName", &self.vendor_name)?;
        }
        if !self.product_name.is_empty() {
            state.serialize_entry("productName", &self.product_name)?;
        }
        if !self.feed.is_empty() {
            state.serialize_entry("feed", &self.feed)?;
        }
        if !self.product_version.is_empty() {
            state.serialize_entry("productVersion", &self.product_version)?;
        }
        if !wkt::internal::is_default(&self.entity_type) {
            state.serialize_entry("entityType", &self.entity_type)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.threat.is_empty() {
            state.serialize_entry("threat", &self.threat)?;
        }
        if !wkt::internal::is_default(&self.source_type) {
            state.serialize_entry("sourceType", &self.source_type)?;
        }
        if !self.source_labels.is_empty() {
            state.serialize_entry("sourceLabels", &self.source_labels)?;
        }
        if self.event_metadata.is_some() {
            state.serialize_entry("eventMetadata", &self.event_metadata)?;
        }
        if self.structured_fields.is_some() {
            state.serialize_entry("structuredFields", &self.structured_fields)?;
        }
        if self.extracted.is_some() {
            state.serialize_entry("extracted", &self.extracted)?;
        }
        if self.ati_prioritization.is_some() {
            state.serialize_entry("atiPrioritization", &self.ati_prioritization)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::AtiPrioritization {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.gti_verdict) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("gtiVerdict", &__With(&self.gti_verdict))?;
        }
        if !wkt::internal::is_default(&self.gti_severity) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("gtiSeverity", &__With(&self.gti_severity))?;
        }
        if !wkt::internal::is_default(&self.gti_threat_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("gtiThreatScore", &__With(&self.gti_threat_score))?;
        }
        if !wkt::internal::is_default(&self.mandiant_analyst_confidence) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "mandiantAnalystConfidence",
                &__With(&self.mandiant_analyst_confidence),
            )?;
        }
        if self.gti_update_time.is_some() {
            state.serialize_entry("gtiUpdateTime", &self.gti_update_time)?;
        }
        if !wkt::internal::is_default(&self.active_ir) {
            state.serialize_entry("activeIr", &self.active_ir)?;
        }
        if self.active_ir_first_tagged_time.is_some() {
            state.serialize_entry("activeIrFirstTaggedTime", &self.active_ir_first_tagged_time)?;
        }
        if !wkt::internal::is_default(&self.global_customer_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("globalCustomerCount", &__With(&self.global_customer_count))?;
        }
        if !wkt::internal::is_default(&self.global_hit_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("globalHitCount", &__With(&self.global_hit_count))?;
        }
        if !wkt::internal::is_default(&self.exclusive) {
            state.serialize_entry("exclusive", &self.exclusive)?;
        }
        if !wkt::internal::is_default(&self.osint) {
            state.serialize_entry("osint", &self.osint)?;
        }
        if !wkt::internal::is_default(&self.scanner) {
            state.serialize_entry("scanner", &self.scanner)?;
        }
        if !wkt::internal::is_default(&self.reviewed) {
            state.serialize_entry("reviewed", &self.reviewed)?;
        }
        if !self.attributed_malware.is_empty() {
            state.serialize_entry("attributedMalware", &self.attributed_malware)?;
        }
        if !self.attributed_threat_actors.is_empty() {
            state.serialize_entry("attributedThreatActors", &self.attributed_threat_actors)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Entity {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.metadata.is_some() {
            state.serialize_entry("metadata", &self.metadata)?;
        }
        if self.entity.is_some() {
            state.serialize_entry("entity", &self.entity)?;
        }
        if !self.relations.is_empty() {
            state.serialize_entry("relations", &self.relations)?;
        }
        if self.additional.is_some() {
            state.serialize_entry("additional", &self.additional)?;
        }
        if self.risk_score.is_some() {
            state.serialize_entry("riskScore", &self.risk_score)?;
        }
        if self.metric.is_some() {
            state.serialize_entry("metric", &self.metric)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Relation {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.entity.is_some() {
            state.serialize_entry("entity", &self.entity)?;
        }
        if !wkt::internal::is_default(&self.entity_type) {
            state.serialize_entry("entityType", &self.entity_type)?;
        }
        if !wkt::internal::is_default(&self.relationship) {
            state.serialize_entry("relationship", &self.relationship)?;
        }
        if !wkt::internal::is_default(&self.direction) {
            state.serialize_entry("direction", &self.direction)?;
        }
        if !self.uid.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("uid", &__With(&self.uid))?;
        }
        if !wkt::internal::is_default(&self.entity_label) {
            state.serialize_entry("entityLabel", &self.entity_label)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Metric {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.first_seen.is_some() {
            state.serialize_entry("firstSeen", &self.first_seen)?;
        }
        if self.last_seen.is_some() {
            state.serialize_entry("lastSeen", &self.last_seen)?;
        }
        if self.sum_measure.is_some() {
            state.serialize_entry("sumMeasure", &self.sum_measure)?;
        }
        if !wkt::internal::is_default(&self.total_events) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("totalEvents", &__With(&self.total_events))?;
        }
        if !wkt::internal::is_default(&self.metric_name) {
            state.serialize_entry("metricName", &self.metric_name)?;
        }
        if !self.dimensions.is_empty() {
            state.serialize_entry("dimensions", &self.dimensions)?;
        }
        if !wkt::internal::is_default(&self.export_window) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("exportWindow", &__With(&self.export_window))?;
        }
        if !self.display_name.is_empty() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.outcome_variables.is_empty() {
            state.serialize_entry("outcomeVariables", &self.outcome_variables)?;
        }
        if !self.match_variables.is_empty() {
            state.serialize_entry("matchVariables", &self.match_variables)?;
        }
        if self.time_range.is_some() {
            state.serialize_entry("timeRange", &self.time_range)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::metric::Measure {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.value) {
            struct __With<'a>(&'a f64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("value", &__With(&self.value))?;
        }
        if !wkt::internal::is_default(&self.aggregate_function) {
            state.serialize_entry("aggregateFunction", &self.aggregate_function)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::EntityRisk {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.risk_version.is_empty() {
            state.serialize_entry("riskVersion", &self.risk_version)?;
        }
        if self.risk_window.is_some() {
            state.serialize_entry("riskWindow", &self.risk_window)?;
        }
        if !wkt::internal::is_default(&self.deprecated_risk_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("DEPRECATEDRiskScore", &__With(&self.deprecated_risk_score))?;
        }
        if self.risk_delta.is_some() {
            state.serialize_entry("riskDelta", &self.risk_delta)?;
        }
        if !wkt::internal::is_default(&self.detections_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("detectionsCount", &__With(&self.detections_count))?;
        }
        if self.first_detection_time.is_some() {
            state.serialize_entry("firstDetectionTime", &self.first_detection_time)?;
        }
        if self.last_detection_time.is_some() {
            state.serialize_entry("lastDetectionTime", &self.last_detection_time)?;
        }
        if !wkt::internal::is_default(&self.risk_score) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("riskScore", &__With(&self.risk_score))?;
        }
        if !wkt::internal::is_default(&self.normalized_risk_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("normalizedRiskScore", &__With(&self.normalized_risk_score))?;
        }
        if self.risk_window_size.is_some() {
            state.serialize_entry("riskWindowSize", &self.risk_window_size)?;
        }
        if self.raw_risk_delta.is_some() {
            state.serialize_entry("rawRiskDelta", &self.raw_risk_delta)?;
        }
        if self.last_reset_time.is_some() {
            state.serialize_entry("lastResetTime", &self.last_reset_time)?;
        }
        if !self.detail_uri.is_empty() {
            state.serialize_entry("detailUri", &self.detail_uri)?;
        }
        if !wkt::internal::is_default(&self.risk_window_has_new_detections) {
            state.serialize_entry(
                "riskWindowHasNewDetections",
                &self.risk_window_has_new_detections,
            )?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::RiskDelta {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.previous_range_end_time.is_some() {
            state.serialize_entry("previousRangeEndTime", &self.previous_range_end_time)?;
        }
        if !wkt::internal::is_default(&self.risk_score_delta) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("riskScoreDelta", &__With(&self.risk_score_delta))?;
        }
        if !wkt::internal::is_default(&self.previous_risk_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("previousRiskScore", &__With(&self.previous_risk_score))?;
        }
        if !wkt::internal::is_default(&self.risk_score_numeric_delta) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "riskScoreNumericDelta",
                &__With(&self.risk_score_numeric_delta),
            )?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Id {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.namespace) {
            state.serialize_entry("namespace", &self.namespace)?;
        }
        if !self.id.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("id", &__With(&self.id))?;
        }
        if !self.string_id.is_empty() {
            state.serialize_entry("stringId", &self.string_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Udm {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.metadata.is_some() {
            state.serialize_entry("metadata", &self.metadata)?;
        }
        if self.additional.is_some() {
            state.serialize_entry("additional", &self.additional)?;
        }
        if self.principal.is_some() {
            state.serialize_entry("principal", &self.principal)?;
        }
        if self.src.is_some() {
            state.serialize_entry("src", &self.src)?;
        }
        if self.target.is_some() {
            state.serialize_entry("target", &self.target)?;
        }
        if !self.intermediary.is_empty() {
            state.serialize_entry("intermediary", &self.intermediary)?;
        }
        if self.observer.is_some() {
            state.serialize_entry("observer", &self.observer)?;
        }
        if !self.about.is_empty() {
            state.serialize_entry("about", &self.about)?;
        }
        if !self.security_result.is_empty() {
            state.serialize_entry("securityResult", &self.security_result)?;
        }
        if self.network.is_some() {
            state.serialize_entry("network", &self.network)?;
        }
        if self.extensions.is_some() {
            state.serialize_entry("extensions", &self.extensions)?;
        }
        if self.extracted.is_some() {
            state.serialize_entry("extracted", &self.extracted)?;
        }
        if self.grouped.is_some() {
            state.serialize_entry("grouped", &self.grouped)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Metadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("id", &__With(&self.id))?;
        }
        if !self.product_log_id.is_empty() {
            state.serialize_entry("productLogId", &self.product_log_id)?;
        }
        if self.event_timestamp.is_some() {
            state.serialize_entry("eventTimestamp", &self.event_timestamp)?;
        }
        if !self.event_timestamp_attributes.is_empty() {
            state.serialize_entry("eventTimestampAttributes", &self.event_timestamp_attributes)?;
        }
        if self.collected_timestamp.is_some() {
            state.serialize_entry("collectedTimestamp", &self.collected_timestamp)?;
        }
        if self.ingested_timestamp.is_some() {
            state.serialize_entry("ingestedTimestamp", &self.ingested_timestamp)?;
        }
        if !wkt::internal::is_default(&self.event_type) {
            state.serialize_entry("eventType", &self.event_type)?;
        }
        if !self.vendor_name.is_empty() {
            state.serialize_entry("vendorName", &self.vendor_name)?;
        }
        if !self.product_name.is_empty() {
            state.serialize_entry("productName", &self.product_name)?;
        }
        if !self.product_version.is_empty() {
            state.serialize_entry("productVersion", &self.product_version)?;
        }
        if !self.product_event_type.is_empty() {
            state.serialize_entry("productEventType", &self.product_event_type)?;
        }
        if !self.product_deployment_id.is_empty() {
            state.serialize_entry("productDeploymentId", &self.product_deployment_id)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.url_back_to_product.is_empty() {
            state.serialize_entry("urlBackToProduct", &self.url_back_to_product)?;
        }
        if !self.ingestion_labels.is_empty() {
            state.serialize_entry("ingestionLabels", &self.ingestion_labels)?;
        }
        if self.tags.is_some() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if !wkt::internal::is_default(&self.enrichment_state) {
            state.serialize_entry("enrichmentState", &self.enrichment_state)?;
        }
        if !self.log_type.is_empty() {
            state.serialize_entry("logType", &self.log_type)?;
        }
        if self.base_labels.is_some() {
            state.serialize_entry("baseLabels", &self.base_labels)?;
        }
        if self.enrichment_labels.is_some() {
            state.serialize_entry("enrichmentLabels", &self.enrichment_labels)?;
        }
        if self.structured_fields.is_some() {
            state.serialize_entry("structuredFields", &self.structured_fields)?;
        }
        if !self.parser_version.is_empty() {
            state.serialize_entry("parserVersion", &self.parser_version)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Attribute {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.cloud.is_some() {
            state.serialize_entry("cloud", &self.cloud)?;
        }
        if !self.labels.is_empty() {
            state.serialize_entry("labels", &self.labels)?;
        }
        if !self.permissions.is_empty() {
            state.serialize_entry("permissions", &self.permissions)?;
        }
        if !self.roles.is_empty() {
            state.serialize_entry("roles", &self.roles)?;
        }
        if self.creation_time.is_some() {
            state.serialize_entry("creationTime", &self.creation_time)?;
        }
        if self.last_update_time.is_some() {
            state.serialize_entry("lastUpdateTime", &self.last_update_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Network {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.sent_bytes) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sentBytes", &__With(&self.sent_bytes))?;
        }
        if !wkt::internal::is_default(&self.received_bytes) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("receivedBytes", &__With(&self.received_bytes))?;
        }
        if !wkt::internal::is_default(&self.total_bytes) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("totalBytes", &__With(&self.total_bytes))?;
        }
        if !wkt::internal::is_default(&self.sent_packets) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sentPackets", &__With(&self.sent_packets))?;
        }
        if !wkt::internal::is_default(&self.received_packets) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("receivedPackets", &__With(&self.received_packets))?;
        }
        if self.session_duration.is_some() {
            state.serialize_entry("sessionDuration", &self.session_duration)?;
        }
        if !self.session_id.is_empty() {
            state.serialize_entry("sessionId", &self.session_id)?;
        }
        if !self.parent_session_id.is_empty() {
            state.serialize_entry("parentSessionId", &self.parent_session_id)?;
        }
        if !self.application_protocol_version.is_empty() {
            state.serialize_entry(
                "applicationProtocolVersion",
                &self.application_protocol_version,
            )?;
        }
        if !self.community_id.is_empty() {
            state.serialize_entry("communityId", &self.community_id)?;
        }
        if !wkt::internal::is_default(&self.direction) {
            state.serialize_entry("direction", &self.direction)?;
        }
        if !wkt::internal::is_default(&self.ip_protocol) {
            state.serialize_entry("ipProtocol", &self.ip_protocol)?;
        }
        if !wkt::internal::is_default(&self.ipv6) {
            state.serialize_entry("ipv6", &self.ipv6)?;
        }
        if !wkt::internal::is_default(&self.application_protocol) {
            state.serialize_entry("applicationProtocol", &self.application_protocol)?;
        }
        if self.ftp.is_some() {
            state.serialize_entry("ftp", &self.ftp)?;
        }
        if self.email.is_some() {
            state.serialize_entry("email", &self.email)?;
        }
        if self.dns.is_some() {
            state.serialize_entry("dns", &self.dns)?;
        }
        if self.dhcp.is_some() {
            state.serialize_entry("dhcp", &self.dhcp)?;
        }
        if self.http.is_some() {
            state.serialize_entry("http", &self.http)?;
        }
        if self.tls.is_some() {
            state.serialize_entry("tls", &self.tls)?;
        }
        if self.smtp.is_some() {
            state.serialize_entry("smtp", &self.smtp)?;
        }
        if !self.asn.is_empty() {
            state.serialize_entry("asn", &self.asn)?;
        }
        if !self.dns_domain.is_empty() {
            state.serialize_entry("dnsDomain", &self.dns_domain)?;
        }
        if !self.carrier_name.is_empty() {
            state.serialize_entry("carrierName", &self.carrier_name)?;
        }
        if !self.organization_name.is_empty() {
            state.serialize_entry("organizationName", &self.organization_name)?;
        }
        if !self.ip_subnet_range.is_empty() {
            state.serialize_entry("ipSubnetRange", &self.ip_subnet_range)?;
        }
        if !wkt::internal::is_default(&self.is_proxy) {
            state.serialize_entry("isProxy", &self.is_proxy)?;
        }
        if self.proxy_info.is_some() {
            state.serialize_entry("proxyInfo", &self.proxy_info)?;
        }
        if !wkt::internal::is_default(&self.connection_state) {
            state.serialize_entry("connectionState", &self.connection_state)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ProxyInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.anonymous) {
            state.serialize_entry("anonymous", &self.anonymous)?;
        }
        if !wkt::internal::is_default(&self.anonymous_vpn) {
            state.serialize_entry("anonymousVpn", &self.anonymous_vpn)?;
        }
        if !wkt::internal::is_default(&self.public_proxy) {
            state.serialize_entry("publicProxy", &self.public_proxy)?;
        }
        if !wkt::internal::is_default(&self.tor_exit_node) {
            state.serialize_entry("torExitNode", &self.tor_exit_node)?;
        }
        if !wkt::internal::is_default(&self.smart_dns_proxy) {
            state.serialize_entry("smartDnsProxy", &self.smart_dns_proxy)?;
        }
        if !wkt::internal::is_default(&self.hosting_provider) {
            state.serialize_entry("hostingProvider", &self.hosting_provider)?;
        }
        if !wkt::internal::is_default(&self.vpn_datacenter) {
            state.serialize_entry("vpnDatacenter", &self.vpn_datacenter)?;
        }
        if !wkt::internal::is_default(&self.residential_proxy) {
            state.serialize_entry("residentialProxy", &self.residential_proxy)?;
        }
        if !self.vpn_service_name.is_empty() {
            state.serialize_entry("vpnServiceName", &self.vpn_service_name)?;
        }
        if !wkt::internal::is_default(&self.proxy_over_vpn) {
            state.serialize_entry("proxyOverVpn", &self.proxy_over_vpn)?;
        }
        if !wkt::internal::is_default(&self.relay_proxy) {
            state.serialize_entry("relayProxy", &self.relay_proxy)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Extensions {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.auth.is_some() {
            state.serialize_entry("auth", &self.auth)?;
        }
        if self.vulns.is_some() {
            state.serialize_entry("vulns", &self.vulns)?;
        }
        if self.entity_risk.is_some() {
            state.serialize_entry("entityRisk", &self.entity_risk)?;
        }
        if self.linux_utmp.is_some() {
            state.serialize_entry("linuxUtmp", &self.linux_utmp)?;
        }
        if self.windows_event_log.is_some() {
            state.serialize_entry("windowsEventLog", &self.windows_event_log)?;
        }
        if self.resource_usage.is_some() {
            state.serialize_entry("resourceUsage", &self.resource_usage)?;
        }
        if self.system_event_details.is_some() {
            state.serialize_entry("systemEventDetails", &self.system_event_details)?;
        }
        if self.outlook_metadata.is_some() {
            state.serialize_entry("outlookMetadata", &self.outlook_metadata)?;
        }
        if self.srum.is_some() {
            state.serialize_entry("srum", &self.srum)?;
        }
        if self.user_assist.is_some() {
            state.serialize_entry("userAssist", &self.user_assist)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Authentication {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.mechanism.is_empty() {
            state.serialize_entry("mechanism", &self.mechanism)?;
        }
        if !self.auth_details.is_empty() {
            state.serialize_entry("authDetails", &self.auth_details)?;
        }
        if !wkt::internal::is_default(&self.outcome) {
            state.serialize_entry("outcome", &self.outcome)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::LinuxUtmp {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.record_type) {
            state.serialize_entry("recordType", &self.record_type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::WindowsEventLog {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.channel) {
            state.serialize_entry("channel", &self.channel)?;
        }
        if !self.event_id.is_empty() {
            state.serialize_entry("eventId", &self.event_id)?;
        }
        if !self.activity_id.is_empty() {
            state.serialize_entry("activityId", &self.activity_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ResourceUsage {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.used_entity.is_empty() {
            state.serialize_entry("usedEntity", &self.used_entity)?;
        }
        if !self.used_entity_id.is_empty() {
            state.serialize_entry("usedEntityId", &self.used_entity_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SystemEventDetails {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.message_type.is_empty() {
            state.serialize_entry("messageType", &self.message_type)?;
        }
        if !self.sender_image_id.is_empty() {
            state.serialize_entry("senderImageId", &self.sender_image_id)?;
        }
        if !self.subsystem.is_empty() {
            state.serialize_entry("subsystem", &self.subsystem)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::OutlookMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.comment.is_empty() {
            state.serialize_entry("comment", &self.comment)?;
        }
        if !self.template.is_empty() {
            state.serialize_entry("template", &self.template)?;
        }
        if !self.title.is_empty() {
            state.serialize_entry("title", &self.title)?;
        }
        if !wkt::internal::is_default(&self.security_flags_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("securityFlagsCount", &__With(&self.security_flags_count))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Srum {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !wkt::internal::is_default(&self.background_bytes_read) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("backgroundBytesRead", &__With(&self.background_bytes_read))?;
        }
        if !wkt::internal::is_default(&self.background_bytes_written) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundBytesWritten",
                &__With(&self.background_bytes_written),
            )?;
        }
        if !wkt::internal::is_default(&self.background_context_switches) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundContextSwitches",
                &__With(&self.background_context_switches),
            )?;
        }
        if !wkt::internal::is_default(&self.background_cycle_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundCycleCount",
                &__With(&self.background_cycle_count),
            )?;
        }
        if !wkt::internal::is_default(&self.background_flushes_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundFlushesCount",
                &__With(&self.background_flushes_count),
            )?;
        }
        if !wkt::internal::is_default(&self.background_read_operations) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundReadOperations",
                &__With(&self.background_read_operations),
            )?;
        }
        if !wkt::internal::is_default(&self.background_write_operations) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "backgroundWriteOperations",
                &__With(&self.background_write_operations),
            )?;
        }
        if !self.interface_luid.is_empty() {
            state.serialize_entry("interfaceLuid", &self.interface_luid)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::UserAssist {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.application_focus_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "applicationFocusCount",
                &__With(&self.application_focus_count),
            )?;
        }
        if self.application_focus_duration.is_some() {
            state.serialize_entry("applicationFocusDuration", &self.application_focus_duration)?;
        }
        if !wkt::internal::is_default(&self.executions_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("executionsCount", &__With(&self.executions_count))?;
        }
        if !wkt::internal::is_default(&self.entry_index) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entryIndex", &__With(&self.entry_index))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Vulnerabilities {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.vulnerabilities.is_empty() {
            state.serialize_entry("vulnerabilities", &self.vulnerabilities)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Vulnerability {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.about.is_some() {
            state.serialize_entry("about", &self.about)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.vendor.is_empty() {
            state.serialize_entry("vendor", &self.vendor)?;
        }
        if self.scan_start_time.is_some() {
            state.serialize_entry("scanStartTime", &self.scan_start_time)?;
        }
        if self.scan_end_time.is_some() {
            state.serialize_entry("scanEndTime", &self.scan_end_time)?;
        }
        if self.first_found.is_some() {
            state.serialize_entry("firstFound", &self.first_found)?;
        }
        if self.last_found.is_some() {
            state.serialize_entry("lastFound", &self.last_found)?;
        }
        if !wkt::internal::is_default(&self.severity) {
            state.serialize_entry("severity", &self.severity)?;
        }
        if !self.severity_details.is_empty() {
            state.serialize_entry("severityDetails", &self.severity_details)?;
        }
        if !wkt::internal::is_default(&self.cvss_base_score) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("cvssBaseScore", &__With(&self.cvss_base_score))?;
        }
        if !self.cvss_vector.is_empty() {
            state.serialize_entry("cvssVector", &self.cvss_vector)?;
        }
        if !self.cvss_version.is_empty() {
            state.serialize_entry("cvssVersion", &self.cvss_version)?;
        }
        if !self.cve_id.is_empty() {
            state.serialize_entry("cveId", &self.cve_id)?;
        }
        if !self.cve_description.is_empty() {
            state.serialize_entry("cveDescription", &self.cve_description)?;
        }
        if !self.vendor_vulnerability_id.is_empty() {
            state.serialize_entry("vendorVulnerabilityId", &self.vendor_vulnerability_id)?;
        }
        if !self.vendor_knowledge_base_article_id.is_empty() {
            state.serialize_entry(
                "vendorKnowledgeBaseArticleId",
                &self.vendor_knowledge_base_article_id,
            )?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Ftp {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.command.is_empty() {
            state.serialize_entry("command", &self.command)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Smtp {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.helo.is_empty() {
            state.serialize_entry("helo", &self.helo)?;
        }
        if !self.mail_from.is_empty() {
            state.serialize_entry("mailFrom", &self.mail_from)?;
        }
        if !self.rcpt_to.is_empty() {
            state.serialize_entry("rcptTo", &self.rcpt_to)?;
        }
        if !self.server_response.is_empty() {
            state.serialize_entry("serverResponse", &self.server_response)?;
        }
        if !self.message_path.is_empty() {
            state.serialize_entry("messagePath", &self.message_path)?;
        }
        if !wkt::internal::is_default(&self.is_webmail) {
            state.serialize_entry("isWebmail", &self.is_webmail)?;
        }
        if !wkt::internal::is_default(&self.is_tls) {
            state.serialize_entry("isTls", &self.is_tls)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Email {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.from.is_empty() {
            state.serialize_entry("from", &self.from)?;
        }
        if !self.reply_to.is_empty() {
            state.serialize_entry("replyTo", &self.reply_to)?;
        }
        if !self.to.is_empty() {
            state.serialize_entry("to", &self.to)?;
        }
        if !self.cc.is_empty() {
            state.serialize_entry("cc", &self.cc)?;
        }
        if !self.bcc.is_empty() {
            state.serialize_entry("bcc", &self.bcc)?;
        }
        if !self.mail_id.is_empty() {
            state.serialize_entry("mailId", &self.mail_id)?;
        }
        if !self.subject.is_empty() {
            state.serialize_entry("subject", &self.subject)?;
        }
        if !self.bounce_address.is_empty() {
            state.serialize_entry("bounceAddress", &self.bounce_address)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Process {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.pid.is_empty() {
            state.serialize_entry("pid", &self.pid)?;
        }
        if !self.parent_pid.is_empty() {
            state.serialize_entry("parentPid", &self.parent_pid)?;
        }
        if self.parent_process.is_some() {
            state.serialize_entry("parentProcess", &self.parent_process)?;
        }
        if self.file.is_some() {
            state.serialize_entry("file", &self.file)?;
        }
        if !self.command_line.is_empty() {
            state.serialize_entry("commandLine", &self.command_line)?;
        }
        if !self.command_line_history.is_empty() {
            state.serialize_entry("commandLineHistory", &self.command_line_history)?;
        }
        if !self.product_specific_process_id.is_empty() {
            state.serialize_entry(
                "productSpecificProcessId",
                &self.product_specific_process_id,
            )?;
        }
        if !wkt::internal::is_default(&self.access_mask) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("accessMask", &__With(&self.access_mask))?;
        }
        if !wkt::internal::is_default(&self.integrity_level_rid) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("integrityLevelRid", &__With(&self.integrity_level_rid))?;
        }
        if !self.euid.is_empty() {
            state.serialize_entry("euid", &self.euid)?;
        }
        if !self.ruid.is_empty() {
            state.serialize_entry("ruid", &self.ruid)?;
        }
        if !self.egid.is_empty() {
            state.serialize_entry("egid", &self.egid)?;
        }
        if !self.rgid.is_empty() {
            state.serialize_entry("rgid", &self.rgid)?;
        }
        if !self.pgid.is_empty() {
            state.serialize_entry("pgid", &self.pgid)?;
        }
        if !self.session_leader_pid.is_empty() {
            state.serialize_entry("sessionLeaderPid", &self.session_leader_pid)?;
        }
        if !self.tty.is_empty() {
            state.serialize_entry("tty", &self.tty)?;
        }
        if !wkt::internal::is_default(&self.token_elevation_type) {
            state.serialize_entry("tokenElevationType", &self.token_elevation_type)?;
        }
        if !self.product_specific_parent_process_id.is_empty() {
            state.serialize_entry(
                "productSpecificParentProcessId",
                &self.product_specific_parent_process_id,
            )?;
        }
        if !wkt::internal::is_default(&self.ipv6) {
            state.serialize_entry("ipv6", &self.ipv6)?;
        }
        if self.kernel_duration.is_some() {
            state.serialize_entry("kernelDuration", &self.kernel_duration)?;
        }
        if self.user_duration.is_some() {
            state.serialize_entry("userDuration", &self.user_duration)?;
        }
        if self.real_duration.is_some() {
            state.serialize_entry("realDuration", &self.real_duration)?;
        }
        if !wkt::internal::is_default(&self.state) {
            state.serialize_entry("state", &self.state)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::AnalyticsMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.analytic.is_empty() {
            state.serialize_entry("analytic", &self.analytic)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FindingVariable {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if !self.source_path.is_empty() {
            state.serialize_entry("sourcePath", &self.source_path)?;
        }
        if let Some(value) = self.bool_val() {
            state.serialize_entry("boolVal", value)?;
        }
        if let Some(value) = self.bytes_val() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("bytesVal", &__With(value))?;
        }
        if let Some(value) = self.double_val() {
            struct __With<'a>(&'a f64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("doubleVal", &__With(value))?;
        }
        if let Some(value) = self.int64_val() {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("int64Val", &__With(value))?;
        }
        if let Some(value) = self.uint64_val() {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("uint64Val", &__With(value))?;
        }
        if let Some(value) = self.string_val() {
            state.serialize_entry("stringVal", value)?;
        }
        if let Some(value) = self.timestamp_time() {
            state.serialize_entry("timestampTime", value)?;
        }
        if let Some(value) = self.null_val() {
            state.serialize_entry("nullVal", value)?;
        }
        if let Some(value) = self.bool_seq() {
            state.serialize_entry("boolSeq", value)?;
        }
        if let Some(value) = self.bytes_seq() {
            state.serialize_entry("bytesSeq", value)?;
        }
        if let Some(value) = self.double_seq() {
            state.serialize_entry("doubleSeq", value)?;
        }
        if let Some(value) = self.int64_seq() {
            state.serialize_entry("int64Seq", value)?;
        }
        if let Some(value) = self.uint64_seq() {
            state.serialize_entry("uint64Seq", value)?;
        }
        if let Some(value) = self.string_seq() {
            state.serialize_entry("stringSeq", value)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SecurityResult {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.about.is_some() {
            state.serialize_entry("about", &self.about)?;
        }
        if !self.category.is_empty() {
            state.serialize_entry("category", &self.category)?;
        }
        if !self.category_details.is_empty() {
            state.serialize_entry("categoryDetails", &self.category_details)?;
        }
        if !self.threat_name.is_empty() {
            state.serialize_entry("threatName", &self.threat_name)?;
        }
        if !self.rule_set.is_empty() {
            state.serialize_entry("ruleSet", &self.rule_set)?;
        }
        if !self.rule_set_display_name.is_empty() {
            state.serialize_entry("ruleSetDisplayName", &self.rule_set_display_name)?;
        }
        if !self.ruleset_category_display_name.is_empty() {
            state.serialize_entry(
                "rulesetCategoryDisplayName",
                &self.ruleset_category_display_name,
            )?;
        }
        if !self.rule_id.is_empty() {
            state.serialize_entry("ruleId", &self.rule_id)?;
        }
        if !self.rule_name.is_empty() {
            state.serialize_entry("ruleName", &self.rule_name)?;
        }
        if !self.display_name.is_empty() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !self.rule_version.is_empty() {
            state.serialize_entry("ruleVersion", &self.rule_version)?;
        }
        if !self.rule_type.is_empty() {
            state.serialize_entry("ruleType", &self.rule_type)?;
        }
        if !self.rule_author.is_empty() {
            state.serialize_entry("ruleAuthor", &self.rule_author)?;
        }
        if !self.rule_labels.is_empty() {
            state.serialize_entry("ruleLabels", &self.rule_labels)?;
        }
        if !wkt::internal::is_default(&self.alert_state) {
            state.serialize_entry("alertState", &self.alert_state)?;
        }
        if !self.detection_fields.is_empty() {
            state.serialize_entry("detectionFields", &self.detection_fields)?;
        }
        if !self.outcomes.is_empty() {
            state.serialize_entry("outcomes", &self.outcomes)?;
        }
        if !self.variables.is_empty() {
            state.serialize_entry("variables", &self.variables)?;
        }
        if !self.summary.is_empty() {
            state.serialize_entry("summary", &self.summary)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.action.is_empty() {
            state.serialize_entry("action", &self.action)?;
        }
        if !self.action_details.is_empty() {
            state.serialize_entry("actionDetails", &self.action_details)?;
        }
        if !wkt::internal::is_default(&self.severity) {
            state.serialize_entry("severity", &self.severity)?;
        }
        if !wkt::internal::is_default(&self.confidence) {
            state.serialize_entry("confidence", &self.confidence)?;
        }
        if !wkt::internal::is_default(&self.priority) {
            state.serialize_entry("priority", &self.priority)?;
        }
        if !wkt::internal::is_default(&self.risk_score) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("riskScore", &__With(&self.risk_score))?;
        }
        if !wkt::internal::is_default(&self.confidence_score) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("confidenceScore", &__With(&self.confidence_score))?;
        }
        if !self.analytics_metadata.is_empty() {
            state.serialize_entry("analyticsMetadata", &self.analytics_metadata)?;
        }
        if !self.severity_details.is_empty() {
            state.serialize_entry("severityDetails", &self.severity_details)?;
        }
        if !self.confidence_details.is_empty() {
            state.serialize_entry("confidenceDetails", &self.confidence_details)?;
        }
        if !self.priority_details.is_empty() {
            state.serialize_entry("priorityDetails", &self.priority_details)?;
        }
        if !self.url_back_to_product.is_empty() {
            state.serialize_entry("urlBackToProduct", &self.url_back_to_product)?;
        }
        if !self.threat_id.is_empty() {
            state.serialize_entry("threatId", &self.threat_id)?;
        }
        if !self.threat_feed_name.is_empty() {
            state.serialize_entry("threatFeedName", &self.threat_feed_name)?;
        }
        if !wkt::internal::is_default(&self.threat_id_namespace) {
            state.serialize_entry("threatIdNamespace", &self.threat_id_namespace)?;
        }
        if !wkt::internal::is_default(&self.threat_status) {
            state.serialize_entry("threatStatus", &self.threat_status)?;
        }
        if self.attack_details.is_some() {
            state.serialize_entry("attackDetails", &self.attack_details)?;
        }
        if self.first_discovered_time.is_some() {
            state.serialize_entry("firstDiscoveredTime", &self.first_discovered_time)?;
        }
        if !self.associations.is_empty() {
            state.serialize_entry("associations", &self.associations)?;
        }
        if !self.campaigns.is_empty() {
            state.serialize_entry("campaigns", &self.campaigns)?;
        }
        if !self.reports.is_empty() {
            state.serialize_entry("reports", &self.reports)?;
        }
        if self.verdict.is_some() {
            state.serialize_entry("verdict", &self.verdict)?;
        }
        if self.last_updated_time.is_some() {
            state.serialize_entry("lastUpdatedTime", &self.last_updated_time)?;
        }
        if !self.verdict_info.is_empty() {
            state.serialize_entry("verdictInfo", &self.verdict_info)?;
        }
        if !wkt::internal::is_default(&self.threat_verdict) {
            state.serialize_entry("threatVerdict", &self.threat_verdict)?;
        }
        if self.last_discovered_time.is_some() {
            state.serialize_entry("lastDiscoveredTime", &self.last_discovered_time)?;
        }
        if !wkt::internal::is_default(&self.detection_depth) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("detectionDepth", &__With(&self.detection_depth))?;
        }
        if !self.threat_collections.is_empty() {
            state.serialize_entry("threatCollections", &self.threat_collections)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::Association {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.country_code.is_empty() {
            state.serialize_entry("countryCode", &self.country_code)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.role.is_empty() {
            state.serialize_entry("role", &self.role)?;
        }
        if !self.source_country.is_empty() {
            state.serialize_entry("sourceCountry", &self.source_country)?;
        }
        if !self.alias.is_empty() {
            state.serialize_entry("alias", &self.alias)?;
        }
        if self.first_reference_time.is_some() {
            state.serialize_entry("firstReferenceTime", &self.first_reference_time)?;
        }
        if self.last_reference_time.is_some() {
            state.serialize_entry("lastReferenceTime", &self.last_reference_time)?;
        }
        if !self.industries_affected.is_empty() {
            state.serialize_entry("industriesAffected", &self.industries_affected)?;
        }
        if !self.associated_actors.is_empty() {
            state.serialize_entry("associatedActors", &self.associated_actors)?;
        }
        if self.region_code.is_some() {
            state.serialize_entry("regionCode", &self.region_code)?;
        }
        if self.sponsor_region.is_some() {
            state.serialize_entry("sponsorRegion", &self.sponsor_region)?;
        }
        if !self.targeted_regions.is_empty() {
            state.serialize_entry("targetedRegions", &self.targeted_regions)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::association::AssociationAlias {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.company.is_empty() {
            state.serialize_entry("company", &self.company)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::Source {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.benign_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("benignCount", &__With(&self.benign_count))?;
        }
        if !wkt::internal::is_default(&self.malicious_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maliciousCount", &__With(&self.malicious_count))?;
        }
        if !wkt::internal::is_default(&self.quality) {
            state.serialize_entry("quality", &self.quality)?;
        }
        if !wkt::internal::is_default(&self.response_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCount", &__With(&self.response_count))?;
        }
        if !wkt::internal::is_default(&self.source_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sourceCount", &__With(&self.source_count))?;
        }
        if !self.threat_intelligence_sources.is_empty() {
            state.serialize_entry(
                "threatIntelligenceSources",
                &self.threat_intelligence_sources,
            )?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::ProviderMLVerdict {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.source_provider.is_empty() {
            state.serialize_entry("sourceProvider", &self.source_provider)?;
        }
        if !wkt::internal::is_default(&self.benign_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("benignCount", &__With(&self.benign_count))?;
        }
        if !wkt::internal::is_default(&self.malicious_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maliciousCount", &__With(&self.malicious_count))?;
        }
        if !wkt::internal::is_default(&self.confidence_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("confidenceScore", &__With(&self.confidence_score))?;
        }
        if !self.mandiant_sources.is_empty() {
            state.serialize_entry("mandiantSources", &self.mandiant_sources)?;
        }
        if !self.third_party_sources.is_empty() {
            state.serialize_entry("thirdPartySources", &self.third_party_sources)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::AnalystVerdict {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.confidence_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("confidenceScore", &__With(&self.confidence_score))?;
        }
        if self.verdict_time.is_some() {
            state.serialize_entry("verdictTime", &self.verdict_time)?;
        }
        if !wkt::internal::is_default(&self.verdict_response) {
            state.serialize_entry("verdictResponse", &self.verdict_response)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::IoCStats {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.ioc_stats_type) {
            state.serialize_entry("iocStatsType", &self.ioc_stats_type)?;
        }
        if !self.first_level_source.is_empty() {
            state.serialize_entry("firstLevelSource", &self.first_level_source)?;
        }
        if !self.second_level_source.is_empty() {
            state.serialize_entry("secondLevelSource", &self.second_level_source)?;
        }
        if !wkt::internal::is_default(&self.benign_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("benignCount", &__With(&self.benign_count))?;
        }
        if !wkt::internal::is_default(&self.quality) {
            state.serialize_entry("quality", &self.quality)?;
        }
        if !wkt::internal::is_default(&self.malicious_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maliciousCount", &__With(&self.malicious_count))?;
        }
        if !wkt::internal::is_default(&self.response_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCount", &__With(&self.response_count))?;
        }
        if !wkt::internal::is_default(&self.source_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sourceCount", &__With(&self.source_count))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::VerdictInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.source_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sourceCount", &__With(&self.source_count))?;
        }
        if !wkt::internal::is_default(&self.response_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCount", &__With(&self.response_count))?;
        }
        if !self.neighbour_influence.is_empty() {
            state.serialize_entry("neighbourInfluence", &self.neighbour_influence)?;
        }
        if !wkt::internal::is_default(&self.verdict_type) {
            state.serialize_entry("verdictType", &self.verdict_type)?;
        }
        if !self.source_provider.is_empty() {
            state.serialize_entry("sourceProvider", &self.source_provider)?;
        }
        if !wkt::internal::is_default(&self.benign_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("benignCount", &__With(&self.benign_count))?;
        }
        if !wkt::internal::is_default(&self.malicious_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maliciousCount", &__With(&self.malicious_count))?;
        }
        if !wkt::internal::is_default(&self.confidence_score) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("confidenceScore", &__With(&self.confidence_score))?;
        }
        if !self.ioc_stats.is_empty() {
            state.serialize_entry("iocStats", &self.ioc_stats)?;
        }
        if self.verdict_time.is_some() {
            state.serialize_entry("verdictTime", &self.verdict_time)?;
        }
        if !wkt::internal::is_default(&self.verdict_response) {
            state.serialize_entry("verdictResponse", &self.verdict_response)?;
        }
        if !wkt::internal::is_default(&self.global_customer_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("globalCustomerCount", &__With(&self.global_customer_count))?;
        }
        if !wkt::internal::is_default(&self.global_hits_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("globalHitsCount", &__With(&self.global_hits_count))?;
        }
        if !wkt::internal::is_default(&self.pwn) {
            state.serialize_entry("pwn", &self.pwn)?;
        }
        if !self.category_details.is_empty() {
            state.serialize_entry("categoryDetails", &self.category_details)?;
        }
        if self.pwn_first_tagged_time.is_some() {
            state.serialize_entry("pwnFirstTaggedTime", &self.pwn_first_tagged_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::Verdict {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.source_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sourceCount", &__With(&self.source_count))?;
        }
        if !wkt::internal::is_default(&self.response_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCount", &__With(&self.response_count))?;
        }
        if !self.neighbour_influence.is_empty() {
            state.serialize_entry("neighbourInfluence", &self.neighbour_influence)?;
        }
        if self.verdict.is_some() {
            state.serialize_entry("verdict", &self.verdict)?;
        }
        if self.analyst_verdict.is_some() {
            state.serialize_entry("analystVerdict", &self.analyst_verdict)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::security_result::ThreatCollectionItem {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.alt_names.is_empty() {
            state.serialize_entry("altNames", &self.alt_names)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::PeFileMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.import_hash.is_empty() {
            state.serialize_entry("importHash", &self.import_hash)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.pe.is_some() {
            state.serialize_entry("pe", &self.pe)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::File {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.sha256.is_empty() {
            state.serialize_entry("sha256", &self.sha256)?;
        }
        if !self.md5.is_empty() {
            state.serialize_entry("md5", &self.md5)?;
        }
        if !self.sha1.is_empty() {
            state.serialize_entry("sha1", &self.sha1)?;
        }
        if !wkt::internal::is_default(&self.size) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("size", &__With(&self.size))?;
        }
        if !self.full_path.is_empty() {
            state.serialize_entry("fullPath", &self.full_path)?;
        }
        if !self.mime_type.is_empty() {
            state.serialize_entry("mimeType", &self.mime_type)?;
        }
        if self.file_metadata.is_some() {
            state.serialize_entry("fileMetadata", &self.file_metadata)?;
        }
        if self.security_result.is_some() {
            state.serialize_entry("securityResult", &self.security_result)?;
        }
        if self.pe_file.is_some() {
            state.serialize_entry("peFile", &self.pe_file)?;
        }
        if !self.ssdeep.is_empty() {
            state.serialize_entry("ssdeep", &self.ssdeep)?;
        }
        if !self.vhash.is_empty() {
            state.serialize_entry("vhash", &self.vhash)?;
        }
        if !self.ahash.is_empty() {
            state.serialize_entry("ahash", &self.ahash)?;
        }
        if !self.authentihash.is_empty() {
            state.serialize_entry("authentihash", &self.authentihash)?;
        }
        if !self.symhash.is_empty() {
            state.serialize_entry("symhash", &self.symhash)?;
        }
        if self.prefetch_file_metadata.is_some() {
            state.serialize_entry("prefetchFileMetadata", &self.prefetch_file_metadata)?;
        }
        if !wkt::internal::is_default(&self.file_type) {
            state.serialize_entry("fileType", &self.file_type)?;
        }
        if !self.capabilities_tags.is_empty() {
            state.serialize_entry("capabilitiesTags", &self.capabilities_tags)?;
        }
        if !self.names.is_empty() {
            state.serialize_entry("names", &self.names)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if self.last_modification_time.is_some() {
            state.serialize_entry("lastModificationTime", &self.last_modification_time)?;
        }
        if self.create_time.is_some() {
            state.serialize_entry("createTime", &self.create_time)?;
        }
        if self.last_access_time.is_some() {
            state.serialize_entry("lastAccessTime", &self.last_access_time)?;
        }
        if self.prevalence.is_some() {
            state.serialize_entry("prevalence", &self.prevalence)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if self.last_seen_time.is_some() {
            state.serialize_entry("lastSeenTime", &self.last_seen_time)?;
        }
        if !wkt::internal::is_default(&self.stat_mode) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("statMode", &__With(&self.stat_mode))?;
        }
        if !wkt::internal::is_default(&self.stat_inode) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("statInode", &__With(&self.stat_inode))?;
        }
        if !wkt::internal::is_default(&self.stat_dev) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("statDev", &__With(&self.stat_dev))?;
        }
        if !wkt::internal::is_default(&self.stat_nlink) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("statNlink", &__With(&self.stat_nlink))?;
        }
        if !wkt::internal::is_default(&self.stat_flags) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("statFlags", &__With(&self.stat_flags))?;
        }
        if self.last_analysis_time.is_some() {
            state.serialize_entry("lastAnalysisTime", &self.last_analysis_time)?;
        }
        if !self.embedded_urls.is_empty() {
            state.serialize_entry("embeddedUrls", &self.embedded_urls)?;
        }
        if !self.embedded_domains.is_empty() {
            state.serialize_entry("embeddedDomains", &self.embedded_domains)?;
        }
        if !self.embedded_ips.is_empty() {
            state.serialize_entry("embeddedIps", &self.embedded_ips)?;
        }
        if self.exif_info.is_some() {
            state.serialize_entry("exifInfo", &self.exif_info)?;
        }
        if self.signature_info.is_some() {
            state.serialize_entry("signatureInfo", &self.signature_info)?;
        }
        if self.pdf_info.is_some() {
            state.serialize_entry("pdfInfo", &self.pdf_info)?;
        }
        if self.first_submission_time.is_some() {
            state.serialize_entry("firstSubmissionTime", &self.first_submission_time)?;
        }
        if self.last_submission_time.is_some() {
            state.serialize_entry("lastSubmissionTime", &self.last_submission_time)?;
        }
        if self.main_icon.is_some() {
            state.serialize_entry("mainIcon", &self.main_icon)?;
        }
        if self.ntfs.is_some() {
            state.serialize_entry("ntfs", &self.ntfs)?;
        }
        if self.app_compat_cache.is_some() {
            state.serialize_entry("appCompatCache", &self.app_compat_cache)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::NtfsFileMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.change_time.is_some() {
            state.serialize_entry("changeTime", &self.change_time)?;
        }
        if self.filename_create_time.is_some() {
            state.serialize_entry("filenameCreateTime", &self.filename_create_time)?;
        }
        if self.filename_modify_time.is_some() {
            state.serialize_entry("filenameModifyTime", &self.filename_modify_time)?;
        }
        if self.filename_access_time.is_some() {
            state.serialize_entry("filenameAccessTime", &self.filename_access_time)?;
        }
        if self.filename_change_time.is_some() {
            state.serialize_entry("filenameChangeTime", &self.filename_change_time)?;
        }
        if !self.usn_journal.is_empty() {
            state.serialize_entry("usnJournal", &self.usn_journal)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::PrefetchFileMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.run_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("runCount", &__With(&self.run_count))?;
        }
        if !self.prefetch_hash.is_empty() {
            state.serialize_entry("prefetchHash", &self.prefetch_hash)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::UsnJournal {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.attributes_flag.is_empty() {
            state.serialize_entry("attributesFlag", &self.attributes_flag)?;
        }
        if !wkt::internal::is_default(&self.attributes) {
            state.serialize_entry("attributes", &self.attributes)?;
        }
        if !self.file_attributes.is_empty() {
            state.serialize_entry("fileAttributes", &self.file_attributes)?;
        }
        if !wkt::internal::is_default(&self.allocated) {
            state.serialize_entry("allocated", &self.allocated)?;
        }
        if !wkt::internal::is_default(&self.reason) {
            state.serialize_entry("reason", &self.reason)?;
        }
        if !self.reasons.is_empty() {
            state.serialize_entry("reasons", &self.reasons)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::AppCompatMetadata {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.sequence) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("sequence", &__With(&self.sequence))?;
        }
        if !wkt::internal::is_default(&self.executed) {
            state.serialize_entry("executed", &self.executed)?;
        }
        if !self.control_set.is_empty() {
            state.serialize_entry("controlSet", &self.control_set)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataPE {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.imphash.is_empty() {
            state.serialize_entry("imphash", &self.imphash)?;
        }
        if !wkt::internal::is_default(&self.entry_point) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entryPoint", &__With(&self.entry_point))?;
        }
        if !wkt::internal::is_default(&self.entry_point_exiftool) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entryPointExiftool", &__With(&self.entry_point_exiftool))?;
        }
        if self.compilation_time.is_some() {
            state.serialize_entry("compilationTime", &self.compilation_time)?;
        }
        if self.compilation_exiftool_time.is_some() {
            state.serialize_entry("compilationExiftoolTime", &self.compilation_exiftool_time)?;
        }
        if !self.section.is_empty() {
            state.serialize_entry("section", &self.section)?;
        }
        if !self.imports.is_empty() {
            state.serialize_entry("imports", &self.imports)?;
        }
        if !self.resource.is_empty() {
            state.serialize_entry("resource", &self.resource)?;
        }
        if !self.resources_type_count.is_empty() {
            state.serialize_entry("resourcesTypeCount", &self.resources_type_count)?;
        }
        if !self.resources_language_count.is_empty() {
            state.serialize_entry("resourcesLanguageCount", &self.resources_language_count)?;
        }
        if !self.resources_type_count_str.is_empty() {
            state.serialize_entry("resourcesTypeCountStr", &self.resources_type_count_str)?;
        }
        if !self.resources_language_count_str.is_empty() {
            state.serialize_entry(
                "resourcesLanguageCountStr",
                &self.resources_language_count_str,
            )?;
        }
        if self.signature_info.is_some() {
            state.serialize_entry("signatureInfo", &self.signature_info)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataPeResourceInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.sha256_hex.is_empty() {
            state.serialize_entry("sha256Hex", &self.sha256_hex)?;
        }
        if !self.filetype_magic.is_empty() {
            state.serialize_entry("filetypeMagic", &self.filetype_magic)?;
        }
        if !self.language_code.is_empty() {
            state.serialize_entry("languageCode", &self.language_code)?;
        }
        if !wkt::internal::is_default(&self.entropy) {
            struct __With<'a>(&'a f64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entropy", &__With(&self.entropy))?;
        }
        if !self.file_type.is_empty() {
            state.serialize_entry("fileType", &self.file_type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SignatureInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.sigcheck.is_some() {
            state.serialize_entry("sigcheck", &self.sigcheck)?;
        }
        if self.codesign.is_some() {
            state.serialize_entry("codesign", &self.codesign)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataSignatureInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.verification_message.is_empty() {
            state.serialize_entry("verificationMessage", &self.verification_message)?;
        }
        if !wkt::internal::is_default(&self.verified) {
            state.serialize_entry("verified", &self.verified)?;
        }
        if !self.signer.is_empty() {
            state.serialize_entry("signer", &self.signer)?;
        }
        if !self.signers.is_empty() {
            state.serialize_entry("signers", &self.signers)?;
        }
        if !self.x509.is_empty() {
            state.serialize_entry("x509", &self.x509)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SignerInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.name.is_some() {
            state.serialize_entry("name", &self.name)?;
        }
        if self.status.is_some() {
            state.serialize_entry("status", &self.status)?;
        }
        if self.valid_usage.is_some() {
            state.serialize_entry("validUsage", &self.valid_usage)?;
        }
        if self.cert_issuer.is_some() {
            state.serialize_entry("certIssuer", &self.cert_issuer)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataCodesign {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.format.is_empty() {
            state.serialize_entry("format", &self.format)?;
        }
        if self.compilation_time.is_some() {
            state.serialize_entry("compilationTime", &self.compilation_time)?;
        }
        if !self.team_id.is_empty() {
            state.serialize_entry("teamId", &self.team_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::X509 {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.algorithm.is_empty() {
            state.serialize_entry("algorithm", &self.algorithm)?;
        }
        if !self.thumbprint.is_empty() {
            state.serialize_entry("thumbprint", &self.thumbprint)?;
        }
        if !self.cert_issuer.is_empty() {
            state.serialize_entry("certIssuer", &self.cert_issuer)?;
        }
        if !self.serial_number.is_empty() {
            state.serialize_entry("serialNumber", &self.serial_number)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::PDFInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.js) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("js", &__With(&self.js))?;
        }
        if !wkt::internal::is_default(&self.javascript) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("javascript", &__With(&self.javascript))?;
        }
        if !wkt::internal::is_default(&self.launch_action_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("launchActionCount", &__With(&self.launch_action_count))?;
        }
        if !wkt::internal::is_default(&self.object_stream_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("objectStreamCount", &__With(&self.object_stream_count))?;
        }
        if !wkt::internal::is_default(&self.endobj_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("endobjCount", &__With(&self.endobj_count))?;
        }
        if !self.header.is_empty() {
            state.serialize_entry("header", &self.header)?;
        }
        if !wkt::internal::is_default(&self.acroform) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("acroform", &__With(&self.acroform))?;
        }
        if !wkt::internal::is_default(&self.autoaction) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("autoaction", &__With(&self.autoaction))?;
        }
        if !wkt::internal::is_default(&self.embedded_file) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("embeddedFile", &__With(&self.embedded_file))?;
        }
        if !wkt::internal::is_default(&self.encrypted) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("encrypted", &__With(&self.encrypted))?;
        }
        if !wkt::internal::is_default(&self.flash) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("flash", &__With(&self.flash))?;
        }
        if !wkt::internal::is_default(&self.jbig2_compression) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("jbig2Compression", &__With(&self.jbig2_compression))?;
        }
        if !wkt::internal::is_default(&self.obj_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("objCount", &__With(&self.obj_count))?;
        }
        if !wkt::internal::is_default(&self.endstream_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("endstreamCount", &__With(&self.endstream_count))?;
        }
        if !wkt::internal::is_default(&self.page_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("pageCount", &__With(&self.page_count))?;
        }
        if !wkt::internal::is_default(&self.stream_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("streamCount", &__With(&self.stream_count))?;
        }
        if !wkt::internal::is_default(&self.openaction) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("openaction", &__With(&self.openaction))?;
        }
        if !wkt::internal::is_default(&self.startxref) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("startxref", &__With(&self.startxref))?;
        }
        if !wkt::internal::is_default(&self.suspicious_colors) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("suspiciousColors", &__With(&self.suspicious_colors))?;
        }
        if !wkt::internal::is_default(&self.trailer) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("trailer", &__With(&self.trailer))?;
        }
        if !wkt::internal::is_default(&self.xfa) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("xfa", &__With(&self.xfa))?;
        }
        if !wkt::internal::is_default(&self.xref) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("xref", &__With(&self.xref))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::StringToInt64MapEntry {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.key.is_some() {
            state.serialize_entry("key", &self.key)?;
        }
        if self.value.is_some() {
            struct __With<'a>(&'a std::option::Option<i64>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::option::Option<wkt::internal::I64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("value", &__With(&self.value))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataSection {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.entropy) {
            struct __With<'a>(&'a f64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entropy", &__With(&self.entropy))?;
        }
        if !wkt::internal::is_default(&self.raw_size_bytes) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("rawSizeBytes", &__With(&self.raw_size_bytes))?;
        }
        if !wkt::internal::is_default(&self.virtual_size_bytes) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("virtualSizeBytes", &__With(&self.virtual_size_bytes))?;
        }
        if !self.md5_hex.is_empty() {
            state.serialize_entry("md5Hex", &self.md5_hex)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::FileMetadataImports {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.library.is_empty() {
            state.serialize_entry("library", &self.library)?;
        }
        if !self.functions.is_empty() {
            state.serialize_entry("functions", &self.functions)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ExifInfo {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.original_file.is_empty() {
            state.serialize_entry("originalFile", &self.original_file)?;
        }
        if !self.product.is_empty() {
            state.serialize_entry("product", &self.product)?;
        }
        if !self.company.is_empty() {
            state.serialize_entry("company", &self.company)?;
        }
        if !self.file_description.is_empty() {
            state.serialize_entry("fileDescription", &self.file_description)?;
        }
        if !wkt::internal::is_default(&self.entry_point) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("entryPoint", &__With(&self.entry_point))?;
        }
        if self.compilation_time.is_some() {
            state.serialize_entry("compilationTime", &self.compilation_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Prevalence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.rolling_max) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("rollingMax", &__With(&self.rolling_max))?;
        }
        if !wkt::internal::is_default(&self.day_count) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("dayCount", &__With(&self.day_count))?;
        }
        if !wkt::internal::is_default(&self.rolling_max_sub_domains) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "rollingMaxSubDomains",
                &__With(&self.rolling_max_sub_domains),
            )?;
        }
        if !wkt::internal::is_default(&self.day_max) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("dayMax", &__With(&self.day_max))?;
        }
        if !wkt::internal::is_default(&self.day_max_sub_domains) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("dayMaxSubDomains", &__With(&self.day_max_sub_domains))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Dns {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.id) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("id", &__With(&self.id))?;
        }
        if !wkt::internal::is_default(&self.response) {
            state.serialize_entry("response", &self.response)?;
        }
        if !wkt::internal::is_default(&self.opcode) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("opcode", &__With(&self.opcode))?;
        }
        if !wkt::internal::is_default(&self.authoritative) {
            state.serialize_entry("authoritative", &self.authoritative)?;
        }
        if !wkt::internal::is_default(&self.truncated) {
            state.serialize_entry("truncated", &self.truncated)?;
        }
        if !wkt::internal::is_default(&self.recursion_desired) {
            state.serialize_entry("recursionDesired", &self.recursion_desired)?;
        }
        if !wkt::internal::is_default(&self.recursion_available) {
            state.serialize_entry("recursionAvailable", &self.recursion_available)?;
        }
        if !wkt::internal::is_default(&self.response_code) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCode", &__With(&self.response_code))?;
        }
        if !self.questions.is_empty() {
            state.serialize_entry("questions", &self.questions)?;
        }
        if !self.answers.is_empty() {
            state.serialize_entry("answers", &self.answers)?;
        }
        if !self.authority.is_empty() {
            state.serialize_entry("authority", &self.authority)?;
        }
        if !self.additional.is_empty() {
            state.serialize_entry("additional", &self.additional)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::dns::Question {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("type", &__With(&self.r#type))?;
        }
        if !wkt::internal::is_default(&self.class) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("class", &__With(&self.class))?;
        }
        if self.prevalence.is_some() {
            state.serialize_entry("prevalence", &self.prevalence)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::dns::ResourceRecord {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("type", &__With(&self.r#type))?;
        }
        if !wkt::internal::is_default(&self.class) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("class", &__With(&self.class))?;
        }
        if !wkt::internal::is_default(&self.ttl) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("ttl", &__With(&self.ttl))?;
        }
        if !self.data.is_empty() {
            state.serialize_entry("data", &self.data)?;
        }
        if !self.binary_data.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("binaryData", &__With(&self.binary_data))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Dhcp {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.opcode) {
            state.serialize_entry("opcode", &self.opcode)?;
        }
        if !wkt::internal::is_default(&self.htype) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("htype", &__With(&self.htype))?;
        }
        if !wkt::internal::is_default(&self.hlen) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("hlen", &__With(&self.hlen))?;
        }
        if !wkt::internal::is_default(&self.hops) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("hops", &__With(&self.hops))?;
        }
        if !wkt::internal::is_default(&self.transaction_id) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("transactionId", &__With(&self.transaction_id))?;
        }
        if !wkt::internal::is_default(&self.seconds) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("seconds", &__With(&self.seconds))?;
        }
        if !wkt::internal::is_default(&self.flags) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("flags", &__With(&self.flags))?;
        }
        if !self.ciaddr.is_empty() {
            state.serialize_entry("ciaddr", &self.ciaddr)?;
        }
        if !self.yiaddr.is_empty() {
            state.serialize_entry("yiaddr", &self.yiaddr)?;
        }
        if !self.siaddr.is_empty() {
            state.serialize_entry("siaddr", &self.siaddr)?;
        }
        if !self.giaddr.is_empty() {
            state.serialize_entry("giaddr", &self.giaddr)?;
        }
        if !self.chaddr.is_empty() {
            state.serialize_entry("chaddr", &self.chaddr)?;
        }
        if !self.sname.is_empty() {
            state.serialize_entry("sname", &self.sname)?;
        }
        if !self.file.is_empty() {
            state.serialize_entry("file", &self.file)?;
        }
        if !self.options.is_empty() {
            state.serialize_entry("options", &self.options)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !wkt::internal::is_default(&self.lease_time_seconds) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("leaseTimeSeconds", &__With(&self.lease_time_seconds))?;
        }
        if !self.client_hostname.is_empty() {
            state.serialize_entry("clientHostname", &self.client_hostname)?;
        }
        if !self.client_identifier.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("clientIdentifier", &__With(&self.client_identifier))?;
        }
        if !self.requested_address.is_empty() {
            state.serialize_entry("requestedAddress", &self.requested_address)?;
        }
        if !self.client_identifier_string.is_empty() {
            state.serialize_entry("clientIdentifierString", &self.client_identifier_string)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::dhcp::Option {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.code) {
            struct __With<'a>(&'a u32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("code", &__With(&self.code))?;
        }
        if !self.data.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("data", &__With(&self.data))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Certificate {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if !self.serial.is_empty() {
            state.serialize_entry("serial", &self.serial)?;
        }
        if !self.subject.is_empty() {
            state.serialize_entry("subject", &self.subject)?;
        }
        if !self.issuer.is_empty() {
            state.serialize_entry("issuer", &self.issuer)?;
        }
        if !self.md5.is_empty() {
            state.serialize_entry("md5", &self.md5)?;
        }
        if !self.sha1.is_empty() {
            state.serialize_entry("sha1", &self.sha1)?;
        }
        if !self.sha256.is_empty() {
            state.serialize_entry("sha256", &self.sha256)?;
        }
        if self.not_before.is_some() {
            state.serialize_entry("notBefore", &self.not_before)?;
        }
        if self.not_after.is_some() {
            state.serialize_entry("notAfter", &self.not_after)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Tls {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.client.is_some() {
            state.serialize_entry("client", &self.client)?;
        }
        if self.server.is_some() {
            state.serialize_entry("server", &self.server)?;
        }
        if !self.cipher.is_empty() {
            state.serialize_entry("cipher", &self.cipher)?;
        }
        if !self.curve.is_empty() {
            state.serialize_entry("curve", &self.curve)?;
        }
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if !self.version_protocol.is_empty() {
            state.serialize_entry("versionProtocol", &self.version_protocol)?;
        }
        if !wkt::internal::is_default(&self.established) {
            state.serialize_entry("established", &self.established)?;
        }
        if !self.next_protocol.is_empty() {
            state.serialize_entry("nextProtocol", &self.next_protocol)?;
        }
        if !wkt::internal::is_default(&self.resumed) {
            state.serialize_entry("resumed", &self.resumed)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::tls::Client {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.certificate.is_some() {
            state.serialize_entry("certificate", &self.certificate)?;
        }
        if !self.ja3.is_empty() {
            state.serialize_entry("ja3", &self.ja3)?;
        }
        if !self.server_name.is_empty() {
            state.serialize_entry("serverName", &self.server_name)?;
        }
        if !self.supported_ciphers.is_empty() {
            state.serialize_entry("supportedCiphers", &self.supported_ciphers)?;
        }
        if !self.ja4.is_empty() {
            state.serialize_entry("ja4", &self.ja4)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::tls::Server {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.certificate.is_some() {
            state.serialize_entry("certificate", &self.certificate)?;
        }
        if !self.ja3s.is_empty() {
            state.serialize_entry("ja3s", &self.ja3s)?;
        }
        if !self.ja4s.is_empty() {
            state.serialize_entry("ja4s", &self.ja4s)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Http {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.method.is_empty() {
            state.serialize_entry("method", &self.method)?;
        }
        if !self.referral_url.is_empty() {
            state.serialize_entry("referralUrl", &self.referral_url)?;
        }
        if !self.user_agent.is_empty() {
            state.serialize_entry("userAgent", &self.user_agent)?;
        }
        if !wkt::internal::is_default(&self.response_code) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("responseCode", &__With(&self.response_code))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Browser {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.browser_type) {
            state.serialize_entry("browserType", &self.browser_type)?;
        }
        if !self.browser_version.is_empty() {
            state.serialize_entry("browserVersion", &self.browser_version)?;
        }
        if self.first_visit_time.is_some() {
            state.serialize_entry("firstVisitTime", &self.first_visit_time)?;
        }
        if self.last_visit_time.is_some() {
            state.serialize_entry("lastVisitTime", &self.last_visit_time)?;
        }
        if !self.profile.is_empty() {
            state.serialize_entry("profile", &self.profile)?;
        }
        if !wkt::internal::is_default(&self.typed) {
            state.serialize_entry("typed", &self.typed)?;
        }
        if !wkt::internal::is_default(&self.visit_type) {
            state.serialize_entry("visitType", &self.visit_type)?;
        }
        if !wkt::internal::is_default(&self.hidden) {
            state.serialize_entry("hidden", &self.hidden)?;
        }
        if !self.request_origin_uri.is_empty() {
            state.serialize_entry("requestOriginUri", &self.request_origin_uri)?;
        }
        if !wkt::internal::is_default(&self.visit_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("visitCount", &__With(&self.visit_count))?;
        }
        if !self.visit_count_criteria.is_empty() {
            state.serialize_entry("visitCountCriteria", &self.visit_count_criteria)?;
        }
        if !self.indexed_content.is_empty() {
            state.serialize_entry("indexedContent", &self.indexed_content)?;
        }
        if self.first_bookmarked_time.is_some() {
            state.serialize_entry("firstBookmarkedTime", &self.first_bookmarked_time)?;
        }
        if !self.cookies.is_empty() {
            state.serialize_entry("cookies", &self.cookies)?;
        }
        if !wkt::internal::is_default(&self.typed_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("typedCount", &__With(&self.typed_count))?;
        }
        if !wkt::internal::is_default(&self.visit_source) {
            state.serialize_entry("visitSource", &self.visit_source)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::browser::Cookie {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if !self.domain.is_empty() {
            state.serialize_entry("domain", &self.domain)?;
        }
        if !self.path.is_empty() {
            state.serialize_entry("path", &self.path)?;
        }
        if self.expiration_time.is_some() {
            state.serialize_entry("expirationTime", &self.expiration_time)?;
        }
        if !wkt::internal::is_default(&self.http_only) {
            state.serialize_entry("httpOnly", &self.http_only)?;
        }
        if !wkt::internal::is_default(&self.secure) {
            state.serialize_entry("secure", &self.secure)?;
        }
        if !wkt::internal::is_default(&self.max_age) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("maxAge", &__With(&self.max_age))?;
        }
        if !wkt::internal::is_default(&self.same_site) {
            state.serialize_entry("sameSite", &self.same_site)?;
        }
        if !wkt::internal::is_default(&self.session) {
            state.serialize_entry("session", &self.session)?;
        }
        if !wkt::internal::is_default(&self.partitioned) {
            state.serialize_entry("partitioned", &self.partitioned)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Hardware {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.serial_number.is_empty() {
            state.serialize_entry("serialNumber", &self.serial_number)?;
        }
        if !self.manufacturer.is_empty() {
            state.serialize_entry("manufacturer", &self.manufacturer)?;
        }
        if !self.model.is_empty() {
            state.serialize_entry("model", &self.model)?;
        }
        if !self.cpu_platform.is_empty() {
            state.serialize_entry("cpuPlatform", &self.cpu_platform)?;
        }
        if !self.cpu_model.is_empty() {
            state.serialize_entry("cpuModel", &self.cpu_model)?;
        }
        if !wkt::internal::is_default(&self.cpu_clock_speed) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("cpuClockSpeed", &__With(&self.cpu_clock_speed))?;
        }
        if !wkt::internal::is_default(&self.cpu_max_clock_speed) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("cpuMaxClockSpeed", &__With(&self.cpu_max_clock_speed))?;
        }
        if !wkt::internal::is_default(&self.cpu_number_cores) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("cpuNumberCores", &__With(&self.cpu_number_cores))?;
        }
        if !wkt::internal::is_default(&self.ram) {
            struct __With<'a>(&'a u64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::U64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("ram", &__With(&self.ram))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::PlatformSoftware {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.platform) {
            state.serialize_entry("platform", &self.platform)?;
        }
        if !self.platform_version.is_empty() {
            state.serialize_entry("platformVersion", &self.platform_version)?;
        }
        if !self.platform_patch_level.is_empty() {
            state.serialize_entry("platformPatchLevel", &self.platform_patch_level)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Software {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if !self.permissions.is_empty() {
            state.serialize_entry("permissions", &self.permissions)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self.vendor_name.is_empty() {
            state.serialize_entry("vendorName", &self.vendor_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Asset {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.product_object_id.is_empty() {
            state.serialize_entry("productObjectId", &self.product_object_id)?;
        }
        if !self.hostname.is_empty() {
            state.serialize_entry("hostname", &self.hostname)?;
        }
        if !self.asset_id.is_empty() {
            state.serialize_entry("assetId", &self.asset_id)?;
        }
        if !self.ip.is_empty() {
            state.serialize_entry("ip", &self.ip)?;
        }
        if !self.mac.is_empty() {
            state.serialize_entry("mac", &self.mac)?;
        }
        if !self.nat_ip.is_empty() {
            state.serialize_entry("natIp", &self.nat_ip)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if !self.hardware.is_empty() {
            state.serialize_entry("hardware", &self.hardware)?;
        }
        if self.platform_software.is_some() {
            state.serialize_entry("platformSoftware", &self.platform_software)?;
        }
        if !self.software.is_empty() {
            state.serialize_entry("software", &self.software)?;
        }
        if self.location.is_some() {
            state.serialize_entry("location", &self.location)?;
        }
        if !self.category.is_empty() {
            state.serialize_entry("category", &self.category)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.network_domain.is_empty() {
            state.serialize_entry("networkDomain", &self.network_domain)?;
        }
        if self.creation_time.is_some() {
            state.serialize_entry("creationTime", &self.creation_time)?;
        }
        if self.first_discover_time.is_some() {
            state.serialize_entry("firstDiscoverTime", &self.first_discover_time)?;
        }
        if self.last_discover_time.is_some() {
            state.serialize_entry("lastDiscoverTime", &self.last_discover_time)?;
        }
        if self.system_last_update_time.is_some() {
            state.serialize_entry("systemLastUpdateTime", &self.system_last_update_time)?;
        }
        if self.last_boot_time.is_some() {
            state.serialize_entry("lastBootTime", &self.last_boot_time)?;
        }
        if !self.labels.is_empty() {
            state.serialize_entry("labels", &self.labels)?;
        }
        if !wkt::internal::is_default(&self.deployment_status) {
            state.serialize_entry("deploymentStatus", &self.deployment_status)?;
        }
        if !self.vulnerabilities.is_empty() {
            state.serialize_entry("vulnerabilities", &self.vulnerabilities)?;
        }
        if self.attribute.is_some() {
            state.serialize_entry("attribute", &self.attribute)?;
        }
        if self.wmi_persistence_item.is_some() {
            state.serialize_entry("wmiPersistenceItem", &self.wmi_persistence_item)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::User {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.product_object_id.is_empty() {
            state.serialize_entry("productObjectId", &self.product_object_id)?;
        }
        if !self.userid.is_empty() {
            state.serialize_entry("userid", &self.userid)?;
        }
        if !self.user_display_name.is_empty() {
            state.serialize_entry("userDisplayName", &self.user_display_name)?;
        }
        if !self.first_name.is_empty() {
            state.serialize_entry("firstName", &self.first_name)?;
        }
        if !self.middle_name.is_empty() {
            state.serialize_entry("middleName", &self.middle_name)?;
        }
        if !self.last_name.is_empty() {
            state.serialize_entry("lastName", &self.last_name)?;
        }
        if !self.phone_numbers.is_empty() {
            state.serialize_entry("phoneNumbers", &self.phone_numbers)?;
        }
        if self.personal_address.is_some() {
            state.serialize_entry("personalAddress", &self.personal_address)?;
        }
        if self.attribute.is_some() {
            state.serialize_entry("attribute", &self.attribute)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if !wkt::internal::is_default(&self.account_type) {
            state.serialize_entry("accountType", &self.account_type)?;
        }
        if !self.groupid.is_empty() {
            state.serialize_entry("groupid", &self.groupid)?;
        }
        if !self.group_identifiers.is_empty() {
            state.serialize_entry("groupIdentifiers", &self.group_identifiers)?;
        }
        if !self.windows_sid.is_empty() {
            state.serialize_entry("windowsSid", &self.windows_sid)?;
        }
        if !self.email_addresses.is_empty() {
            state.serialize_entry("emailAddresses", &self.email_addresses)?;
        }
        if !self.employee_id.is_empty() {
            state.serialize_entry("employeeId", &self.employee_id)?;
        }
        if !self.title.is_empty() {
            state.serialize_entry("title", &self.title)?;
        }
        if !self.company_name.is_empty() {
            state.serialize_entry("companyName", &self.company_name)?;
        }
        if !self.department.is_empty() {
            state.serialize_entry("department", &self.department)?;
        }
        if self.office_address.is_some() {
            state.serialize_entry("officeAddress", &self.office_address)?;
        }
        if !self.managers.is_empty() {
            state.serialize_entry("managers", &self.managers)?;
        }
        if self.hire_date.is_some() {
            state.serialize_entry("hireDate", &self.hire_date)?;
        }
        if self.termination_date.is_some() {
            state.serialize_entry("terminationDate", &self.termination_date)?;
        }
        if !self.time_off.is_empty() {
            state.serialize_entry("timeOff", &self.time_off)?;
        }
        if self.last_login_time.is_some() {
            state.serialize_entry("lastLoginTime", &self.last_login_time)?;
        }
        if self.last_password_change_time.is_some() {
            state.serialize_entry("lastPasswordChangeTime", &self.last_password_change_time)?;
        }
        if self.password_expiration_time.is_some() {
            state.serialize_entry("passwordExpirationTime", &self.password_expiration_time)?;
        }
        if self.account_expiration_time.is_some() {
            state.serialize_entry("accountExpirationTime", &self.account_expiration_time)?;
        }
        if self.account_lockout_time.is_some() {
            state.serialize_entry("accountLockoutTime", &self.account_lockout_time)?;
        }
        if self.last_bad_password_attempt_time.is_some() {
            state.serialize_entry(
                "lastBadPasswordAttemptTime",
                &self.last_bad_password_attempt_time,
            )?;
        }
        if !wkt::internal::is_default(&self.user_authentication_status) {
            state.serialize_entry("userAuthenticationStatus", &self.user_authentication_status)?;
        }
        if !self.role_name.is_empty() {
            state.serialize_entry("roleName", &self.role_name)?;
        }
        if !self.role_description.is_empty() {
            state.serialize_entry("roleDescription", &self.role_description)?;
        }
        if !wkt::internal::is_default(&self.user_role) {
            state.serialize_entry("userRole", &self.user_role)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::TimeOff {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.interval.is_some() {
            state.serialize_entry("interval", &self.interval)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Permission {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Role {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.description.is_empty() {
            state.serialize_entry("description", &self.description)?;
        }
        if !wkt::internal::is_default(&self.r#type) {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Group {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.product_object_id.is_empty() {
            state.serialize_entry("productObjectId", &self.product_object_id)?;
        }
        if self.creation_time.is_some() {
            state.serialize_entry("creationTime", &self.creation_time)?;
        }
        if !self.group_display_name.is_empty() {
            state.serialize_entry("groupDisplayName", &self.group_display_name)?;
        }
        if self.attribute.is_some() {
            state.serialize_entry("attribute", &self.attribute)?;
        }
        if !self.email_addresses.is_empty() {
            state.serialize_entry("emailAddresses", &self.email_addresses)?;
        }
        if !self.windows_sid.is_empty() {
            state.serialize_entry("windowsSid", &self.windows_sid)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Registry {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.registry_key.is_empty() {
            state.serialize_entry("registryKey", &self.registry_key)?;
        }
        if !self.registry_value_name.is_empty() {
            state.serialize_entry("registryValueName", &self.registry_value_name)?;
        }
        if !self.registry_value_data.is_empty() {
            state.serialize_entry("registryValueData", &self.registry_value_data)?;
        }
        if !wkt::internal::is_default(&self.registry_value_type) {
            state.serialize_entry("registryValueType", &self.registry_value_type)?;
        }
        if !self.registry_value_binary_data.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "registryValueBinaryData",
                &__With(&self.registry_value_binary_data),
            )?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::WmiPersistenceItem {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.caption.is_empty() {
            state.serialize_entry("caption", &self.caption)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.setting_id.is_empty() {
            state.serialize_entry("settingId", &self.setting_id)?;
        }
        if !self.derivation.is_empty() {
            state.serialize_entry("derivation", &self.derivation)?;
        }
        if !wkt::internal::is_default(&self.property_count) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("propertyCount", &__With(&self.property_count))?;
        }
        if !self.rel_path.is_empty() {
            state.serialize_entry("relPath", &self.rel_path)?;
        }
        if !self.dynasty.is_empty() {
            state.serialize_entry("dynasty", &self.dynasty)?;
        }
        if !self.wmi_super_class.is_empty() {
            state.serialize_entry("wmiSuperClass", &self.wmi_super_class)?;
        }
        if !self.wmi_class.is_empty() {
            state.serialize_entry("wmiClass", &self.wmi_class)?;
        }
        if !wkt::internal::is_default(&self.genus) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("genus", &__With(&self.genus))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Location {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.city.is_empty() {
            state.serialize_entry("city", &self.city)?;
        }
        if !self.state.is_empty() {
            state.serialize_entry("state", &self.state)?;
        }
        if !self.country_or_region.is_empty() {
            state.serialize_entry("countryOrRegion", &self.country_or_region)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.desk_name.is_empty() {
            state.serialize_entry("deskName", &self.desk_name)?;
        }
        if !self.floor_name.is_empty() {
            state.serialize_entry("floorName", &self.floor_name)?;
        }
        if !wkt::internal::is_default(&self.region_latitude) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("regionLatitude", &__With(&self.region_latitude))?;
        }
        if !wkt::internal::is_default(&self.region_longitude) {
            struct __With<'a>(&'a f32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::F32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("regionLongitude", &__With(&self.region_longitude))?;
        }
        if self.region_coordinates.is_some() {
            state.serialize_entry("regionCoordinates", &self.region_coordinates)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ScheduledTask {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.minute) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("minute", &__With(&self.minute))?;
        }
        if !wkt::internal::is_default(&self.hour) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("hour", &__With(&self.hour))?;
        }
        if !wkt::internal::is_default(&self.month_day) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("monthDay", &__With(&self.month_day))?;
        }
        if !wkt::internal::is_default(&self.month) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("month", &__With(&self.month))?;
        }
        if !wkt::internal::is_default(&self.week_day) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("weekDay", &__With(&self.week_day))?;
        }
        if !self.comment.is_empty() {
            state.serialize_entry("comment", &self.comment)?;
        }
        if !self.author.is_empty() {
            state.serialize_entry("author", &self.author)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::WindowsScheduledTask {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.author.is_empty() {
            state.serialize_entry("author", &self.author)?;
        }
        if !self.virtual_path.is_empty() {
            state.serialize_entry("virtualPath", &self.virtual_path)?;
        }
        if !wkt::internal::is_default(&self.exit_code) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("exitCode", &__With(&self.exit_code))?;
        }
        if !wkt::internal::is_default(&self.state) {
            state.serialize_entry("state", &self.state)?;
        }
        if !wkt::internal::is_default(&self.logon_type) {
            state.serialize_entry("logonType", &self.logon_type)?;
        }
        if !self.task_actions.is_empty() {
            state.serialize_entry("taskActions", &self.task_actions)?;
        }
        if !self.task_triggers.is_empty() {
            state.serialize_entry("taskTriggers", &self.task_triggers)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::windows_scheduled_task::TaskAction {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.action_type) {
            state.serialize_entry("actionType", &self.action_type)?;
        }
        if !self.exec_arguments.is_empty() {
            state.serialize_entry("execArguments", &self.exec_arguments)?;
        }
        if !self.exec_working_directory.is_empty() {
            state.serialize_entry("execWorkingDirectory", &self.exec_working_directory)?;
        }
        if !self.com_class_id.is_empty() {
            state.serialize_entry("comClassId", &self.com_class_id)?;
        }
        if !self.com_data.is_empty() {
            state.serialize_entry("comData", &self.com_data)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::windows_scheduled_task::TaskTrigger {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.enabled) {
            state.serialize_entry("enabled", &self.enabled)?;
        }
        if self.duration.is_some() {
            state.serialize_entry("duration", &self.duration)?;
        }
        if !self.interval.is_empty() {
            state.serialize_entry("interval", &self.interval)?;
        }
        if !wkt::internal::is_default(&self.trigger_type) {
            state.serialize_entry("triggerType", &self.trigger_type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ScheduledCronTask {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.minute.is_empty() {
            state.serialize_entry("minute", &self.minute)?;
        }
        if !self.hour.is_empty() {
            state.serialize_entry("hour", &self.hour)?;
        }
        if !self.month_day.is_empty() {
            state.serialize_entry("monthDay", &self.month_day)?;
        }
        if !self.month.is_empty() {
            state.serialize_entry("month", &self.month)?;
        }
        if !self.week_day.is_empty() {
            state.serialize_entry("weekDay", &self.week_day)?;
        }
        if !self.comment.is_empty() {
            state.serialize_entry("comment", &self.comment)?;
        }
        if !self.author.is_empty() {
            state.serialize_entry("author", &self.author)?;
        }
        if !self.event.is_empty() {
            state.serialize_entry("event", &self.event)?;
        }
        if !self.path.is_empty() {
            state.serialize_entry("path", &self.path)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ScheduledAnacronTask {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.period.is_empty() {
            state.serialize_entry("period", &self.period)?;
        }
        if !wkt::internal::is_default(&self.delay_minutes) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("delayMinutes", &__With(&self.delay_minutes))?;
        }
        if !self.job_id.is_empty() {
            state.serialize_entry("jobId", &self.job_id)?;
        }
        if !self.path.is_empty() {
            state.serialize_entry("path", &self.path)?;
        }
        if !self.source_line.is_empty() {
            state.serialize_entry("sourceLine", &self.source_line)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Volume {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.file_system.is_empty() {
            state.serialize_entry("fileSystem", &self.file_system)?;
        }
        if !self.mount_point.is_empty() {
            state.serialize_entry("mountPoint", &self.mount_point)?;
        }
        if !self.device_path.is_empty() {
            state.serialize_entry("devicePath", &self.device_path)?;
        }
        if !wkt::internal::is_default(&self.is_mounted) {
            state.serialize_entry("isMounted", &self.is_mounted)?;
        }
        if !wkt::internal::is_default(&self.is_read_only) {
            state.serialize_entry("isReadOnly", &self.is_read_only)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Service {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.display_name.is_empty() {
            state.serialize_entry("displayName", &self.display_name)?;
        }
        if !wkt::internal::is_default(&self.service_type) {
            state.serialize_entry("serviceType", &self.service_type)?;
        }
        if !self.service_types.is_empty() {
            state.serialize_entry("serviceTypes", &self.service_types)?;
        }
        if !wkt::internal::is_default(&self.startup_type) {
            state.serialize_entry("startupType", &self.startup_type)?;
        }
        if !wkt::internal::is_default(&self.state) {
            state.serialize_entry("state", &self.state)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Resource {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.r#type.is_empty() {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !wkt::internal::is_default(&self.resource_type) {
            state.serialize_entry("resourceType", &self.resource_type)?;
        }
        if !self.resource_subtype.is_empty() {
            state.serialize_entry("resourceSubtype", &self.resource_subtype)?;
        }
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.parent.is_empty() {
            state.serialize_entry("parent", &self.parent)?;
        }
        if !self.product_object_id.is_empty() {
            state.serialize_entry("productObjectId", &self.product_object_id)?;
        }
        if self.attribute.is_some() {
            state.serialize_entry("attribute", &self.attribute)?;
        }
        if self.scheduled_task.is_some() {
            state.serialize_entry("scheduledTask", &self.scheduled_task)?;
        }
        if self.scheduled_cron_task.is_some() {
            state.serialize_entry("scheduledCronTask", &self.scheduled_cron_task)?;
        }
        if self.scheduled_anacron_task.is_some() {
            state.serialize_entry("scheduledAnacronTask", &self.scheduled_anacron_task)?;
        }
        if self.windows_scheduled_task.is_some() {
            state.serialize_entry("windowsScheduledTask", &self.windows_scheduled_task)?;
        }
        if self.volume.is_some() {
            state.serialize_entry("volume", &self.volume)?;
        }
        if self.service.is_some() {
            state.serialize_entry("service", &self.service)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Label {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.key.is_empty() {
            state.serialize_entry("key", &self.key)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if !self.source.is_empty() {
            state.serialize_entry("source", &self.source)?;
        }
        if !wkt::internal::is_default(&self.rbac_enabled) {
            state.serialize_entry("rbacEnabled", &self.rbac_enabled)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Cloud {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.environment) {
            state.serialize_entry("environment", &self.environment)?;
        }
        if self.vpc.is_some() {
            state.serialize_entry("vpc", &self.vpc)?;
        }
        if self.project.is_some() {
            state.serialize_entry("project", &self.project)?;
        }
        if !self.availability_zone.is_empty() {
            state.serialize_entry("availabilityZone", &self.availability_zone)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Artifact {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.ip.is_empty() {
            state.serialize_entry("ip", &self.ip)?;
        }
        if self.prevalence.is_some() {
            state.serialize_entry("prevalence", &self.prevalence)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if self.last_seen_time.is_some() {
            state.serialize_entry("lastSeenTime", &self.last_seen_time)?;
        }
        if self.location.is_some() {
            state.serialize_entry("location", &self.location)?;
        }
        if self.network.is_some() {
            state.serialize_entry("network", &self.network)?;
        }
        if !self.as_owner.is_empty() {
            state.serialize_entry("asOwner", &self.as_owner)?;
        }
        if !wkt::internal::is_default(&self.asn) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("asn", &__With(&self.asn))?;
        }
        if !self.jarm.is_empty() {
            state.serialize_entry("jarm", &self.jarm)?;
        }
        if self.last_https_certificate.is_some() {
            state.serialize_entry("lastHttpsCertificate", &self.last_https_certificate)?;
        }
        if self.last_https_certificate_date.is_some() {
            state.serialize_entry(
                "lastHttpsCertificateDate",
                &self.last_https_certificate_date,
            )?;
        }
        if !self.regional_internet_registry.is_empty() {
            state.serialize_entry("regionalInternetRegistry", &self.regional_internet_registry)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if !self.whois.is_empty() {
            state.serialize_entry("whois", &self.whois)?;
        }
        if self.whois_date.is_some() {
            state.serialize_entry("whoisDate", &self.whois_date)?;
        }
        if !self.tunnels.is_empty() {
            state.serialize_entry("tunnels", &self.tunnels)?;
        }
        if !wkt::internal::is_default(&self.anonymous) {
            state.serialize_entry("anonymous", &self.anonymous)?;
        }
        if self.artifact_client.is_some() {
            state.serialize_entry("artifactClient", &self.artifact_client)?;
        }
        if !self.risks.is_empty() {
            state.serialize_entry("risks", &self.risks)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Tunnels {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.provider.is_empty() {
            state.serialize_entry("provider", &self.provider)?;
        }
        if !self.r#type.is_empty() {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ArtifactClient {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.behaviors.is_empty() {
            state.serialize_entry("behaviors", &self.behaviors)?;
        }
        if !self.proxies.is_empty() {
            state.serialize_entry("proxies", &self.proxies)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Favicon {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.raw_md5.is_empty() {
            state.serialize_entry("rawMd5", &self.raw_md5)?;
        }
        if !self.dhash.is_empty() {
            state.serialize_entry("dhash", &self.dhash)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::DNSRecord {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.r#type.is_empty() {
            state.serialize_entry("type", &self.r#type)?;
        }
        if !self.value.is_empty() {
            state.serialize_entry("value", &self.value)?;
        }
        if self.ttl.is_some() {
            state.serialize_entry("ttl", &self.ttl)?;
        }
        if !wkt::internal::is_default(&self.priority) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("priority", &__With(&self.priority))?;
        }
        if !wkt::internal::is_default(&self.retry) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("retry", &__With(&self.retry))?;
        }
        if self.refresh.is_some() {
            state.serialize_entry("refresh", &self.refresh)?;
        }
        if self.minimum.is_some() {
            state.serialize_entry("minimum", &self.minimum)?;
        }
        if self.expire.is_some() {
            state.serialize_entry("expire", &self.expire)?;
        }
        if !wkt::internal::is_default(&self.serial) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("serial", &__With(&self.serial))?;
        }
        if !self.rname.is_empty() {
            state.serialize_entry("rname", &self.rname)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::SSLCertificate {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.cert_signature.is_some() {
            state.serialize_entry("certSignature", &self.cert_signature)?;
        }
        if self.extension.is_some() {
            state.serialize_entry("extension", &self.extension)?;
        }
        if self.cert_extensions.is_some() {
            state.serialize_entry("certExtensions", &self.cert_extensions)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if self.issuer.is_some() {
            state.serialize_entry("issuer", &self.issuer)?;
        }
        if self.ec.is_some() {
            state.serialize_entry("ec", &self.ec)?;
        }
        if !self.serial_number.is_empty() {
            state.serialize_entry("serialNumber", &self.serial_number)?;
        }
        if !self.signature_algorithm.is_empty() {
            state.serialize_entry("signatureAlgorithm", &self.signature_algorithm)?;
        }
        if !wkt::internal::is_default(&self.size) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("size", &__With(&self.size))?;
        }
        if self.subject.is_some() {
            state.serialize_entry("subject", &self.subject)?;
        }
        if !self.thumbprint.is_empty() {
            state.serialize_entry("thumbprint", &self.thumbprint)?;
        }
        if !self.thumbprint_sha256.is_empty() {
            state.serialize_entry("thumbprintSha256", &self.thumbprint_sha256)?;
        }
        if self.validity.is_some() {
            state.serialize_entry("validity", &self.validity)?;
        }
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if self.public_key.is_some() {
            state.serialize_entry("publicKey", &self.public_key)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::CertSignature {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.signature.is_empty() {
            state.serialize_entry("signature", &self.signature)?;
        }
        if !self.signature_algorithm.is_empty() {
            state.serialize_entry("signatureAlgorithm", &self.signature_algorithm)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::AuthorityKeyId {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.keyid.is_empty() {
            state.serialize_entry("keyid", &self.keyid)?;
        }
        if !self.serial_number.is_empty() {
            state.serialize_entry("serialNumber", &self.serial_number)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::Extension {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.ca) {
            state.serialize_entry("ca", &self.ca)?;
        }
        if !self.subject_key_id.is_empty() {
            state.serialize_entry("subjectKeyId", &self.subject_key_id)?;
        }
        if self.authority_key_id.is_some() {
            state.serialize_entry("authorityKeyId", &self.authority_key_id)?;
        }
        if !self.key_usage.is_empty() {
            state.serialize_entry("keyUsage", &self.key_usage)?;
        }
        if !self.ca_info_access.is_empty() {
            state.serialize_entry("caInfoAccess", &self.ca_info_access)?;
        }
        if !self.crl_distribution_points.is_empty() {
            state.serialize_entry("crlDistributionPoints", &self.crl_distribution_points)?;
        }
        if !self.extended_key_usage.is_empty() {
            state.serialize_entry("extendedKeyUsage", &self.extended_key_usage)?;
        }
        if !self.subject_alternative_name.is_empty() {
            state.serialize_entry("subjectAlternativeName", &self.subject_alternative_name)?;
        }
        if !self.certificate_policies.is_empty() {
            state.serialize_entry("certificatePolicies", &self.certificate_policies)?;
        }
        if !self.netscape_cert_comment.is_empty() {
            state.serialize_entry("netscapeCertComment", &self.netscape_cert_comment)?;
        }
        if !self.cert_template_name_dc.is_empty() {
            state.serialize_entry("certTemplateNameDc", &self.cert_template_name_dc)?;
        }
        if !wkt::internal::is_default(&self.netscape_certificate) {
            state.serialize_entry("netscapeCertificate", &self.netscape_certificate)?;
        }
        if !wkt::internal::is_default(&self.pe_logotype) {
            state.serialize_entry("peLogotype", &self.pe_logotype)?;
        }
        if !wkt::internal::is_default(&self.old_authority_key_id) {
            state.serialize_entry("oldAuthorityKeyId", &self.old_authority_key_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::Subject {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.country_name.is_empty() {
            state.serialize_entry("countryName", &self.country_name)?;
        }
        if !self.common_name.is_empty() {
            state.serialize_entry("commonName", &self.common_name)?;
        }
        if !self.locality.is_empty() {
            state.serialize_entry("locality", &self.locality)?;
        }
        if !self.organization.is_empty() {
            state.serialize_entry("organization", &self.organization)?;
        }
        if !self.organizational_unit.is_empty() {
            state.serialize_entry("organizationalUnit", &self.organizational_unit)?;
        }
        if !self.state_or_province_name.is_empty() {
            state.serialize_entry("stateOrProvinceName", &self.state_or_province_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::Rsa {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !wkt::internal::is_default(&self.key_size) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("keySize", &__With(&self.key_size))?;
        }
        if !self.modulus.is_empty() {
            state.serialize_entry("modulus", &self.modulus)?;
        }
        if !self.exponent.is_empty() {
            state.serialize_entry("exponent", &self.exponent)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::Ec {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.oid.is_empty() {
            state.serialize_entry("oid", &self.oid)?;
        }
        if !self.r#pub.is_empty() {
            state.serialize_entry("pub", &self.r#pub)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::PublicKey {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.algorithm.is_empty() {
            state.serialize_entry("algorithm", &self.algorithm)?;
        }
        if self.rsa.is_some() {
            state.serialize_entry("rsa", &self.rsa)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::ssl_certificate::Validity {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.expiry_time.is_some() {
            state.serialize_entry("expiryTime", &self.expiry_time)?;
        }
        if self.issue_time.is_some() {
            state.serialize_entry("issueTime", &self.issue_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::PopularityRank {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.giver.is_empty() {
            state.serialize_entry("giver", &self.giver)?;
        }
        if !wkt::internal::is_default(&self.rank) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("rank", &__With(&self.rank))?;
        }
        if self.ingestion_time.is_some() {
            state.serialize_entry("ingestionTime", &self.ingestion_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Tracker {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.tracker.is_empty() {
            state.serialize_entry("tracker", &self.tracker)?;
        }
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if self.timestamp.is_some() {
            state.serialize_entry("timestamp", &self.timestamp)?;
        }
        if !self.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Url {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if !self.categories.is_empty() {
            state.serialize_entry("categories", &self.categories)?;
        }
        if self.favicon.is_some() {
            state.serialize_entry("favicon", &self.favicon)?;
        }
        if self.html_meta.is_some() {
            state.serialize_entry("htmlMeta", &self.html_meta)?;
        }
        if !self.last_final_url.is_empty() {
            state.serialize_entry("lastFinalUrl", &self.last_final_url)?;
        }
        if !wkt::internal::is_default(&self.last_http_response_code) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "lastHttpResponseCode",
                &__With(&self.last_http_response_code),
            )?;
        }
        if !wkt::internal::is_default(&self.last_http_response_content_length) {
            struct __With<'a>(&'a i64);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry(
                "lastHttpResponseContentLength",
                &__With(&self.last_http_response_content_length),
            )?;
        }
        if !self.last_http_response_content_sha256.is_empty() {
            state.serialize_entry(
                "lastHttpResponseContentSha256",
                &self.last_http_response_content_sha256,
            )?;
        }
        if self.last_http_response_cookies.is_some() {
            state.serialize_entry("lastHttpResponseCookies", &self.last_http_response_cookies)?;
        }
        if self.last_http_response_headers.is_some() {
            state.serialize_entry("lastHttpResponseHeaders", &self.last_http_response_headers)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if !self.title.is_empty() {
            state.serialize_entry("title", &self.title)?;
        }
        if !self.trackers.is_empty() {
            state.serialize_entry("trackers", &self.trackers)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Domain {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if self.prevalence.is_some() {
            state.serialize_entry("prevalence", &self.prevalence)?;
        }
        if self.first_seen_time.is_some() {
            state.serialize_entry("firstSeenTime", &self.first_seen_time)?;
        }
        if self.last_seen_time.is_some() {
            state.serialize_entry("lastSeenTime", &self.last_seen_time)?;
        }
        if !self.registrar.is_empty() {
            state.serialize_entry("registrar", &self.registrar)?;
        }
        if !self.contact_email.is_empty() {
            state.serialize_entry("contactEmail", &self.contact_email)?;
        }
        if !self.whois_server.is_empty() {
            state.serialize_entry("whoisServer", &self.whois_server)?;
        }
        if !self.name_server.is_empty() {
            state.serialize_entry("nameServer", &self.name_server)?;
        }
        if self.creation_time.is_some() {
            state.serialize_entry("creationTime", &self.creation_time)?;
        }
        if self.update_time.is_some() {
            state.serialize_entry("updateTime", &self.update_time)?;
        }
        if self.expiration_time.is_some() {
            state.serialize_entry("expirationTime", &self.expiration_time)?;
        }
        if self.audit_update_time.is_some() {
            state.serialize_entry("auditUpdateTime", &self.audit_update_time)?;
        }
        if !self.status.is_empty() {
            state.serialize_entry("status", &self.status)?;
        }
        if self.registrant.is_some() {
            state.serialize_entry("registrant", &self.registrant)?;
        }
        if self.admin.is_some() {
            state.serialize_entry("admin", &self.admin)?;
        }
        if self.tech.is_some() {
            state.serialize_entry("tech", &self.tech)?;
        }
        if self.billing.is_some() {
            state.serialize_entry("billing", &self.billing)?;
        }
        if self.zone.is_some() {
            state.serialize_entry("zone", &self.zone)?;
        }
        if !self.whois_record_raw_text.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("whoisRecordRawText", &__With(&self.whois_record_raw_text))?;
        }
        if !self.registry_data_raw_text.is_empty() {
            struct __With<'a>(&'a ::bytes::Bytes);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("registryDataRawText", &__With(&self.registry_data_raw_text))?;
        }
        if !wkt::internal::is_default(&self.iana_registrar_id) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("ianaRegistrarId", &__With(&self.iana_registrar_id))?;
        }
        if !wkt::internal::is_default(&self.private_registration) {
            state.serialize_entry("privateRegistration", &self.private_registration)?;
        }
        if !self.categories.is_empty() {
            state.serialize_entry("categories", &self.categories)?;
        }
        if self.favicon.is_some() {
            state.serialize_entry("favicon", &self.favicon)?;
        }
        if !self.jarm.is_empty() {
            state.serialize_entry("jarm", &self.jarm)?;
        }
        if !self.last_dns_records.is_empty() {
            state.serialize_entry("lastDnsRecords", &self.last_dns_records)?;
        }
        if self.last_dns_records_time.is_some() {
            state.serialize_entry("lastDnsRecordsTime", &self.last_dns_records_time)?;
        }
        if self.last_https_certificate.is_some() {
            state.serialize_entry("lastHttpsCertificate", &self.last_https_certificate)?;
        }
        if self.last_https_certificate_time.is_some() {
            state.serialize_entry(
                "lastHttpsCertificateTime",
                &self.last_https_certificate_time,
            )?;
        }
        if !self.popularity_ranks.is_empty() {
            state.serialize_entry("popularityRanks", &self.popularity_ranks)?;
        }
        if !self.tags.is_empty() {
            state.serialize_entry("tags", &self.tags)?;
        }
        if self.whois_time.is_some() {
            state.serialize_entry("whoisTime", &self.whois_time)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Noun {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.hostname.is_empty() {
            state.serialize_entry("hostname", &self.hostname)?;
        }
        if self.domain.is_some() {
            state.serialize_entry("domain", &self.domain)?;
        }
        if self.artifact.is_some() {
            state.serialize_entry("artifact", &self.artifact)?;
        }
        if self.url_metadata.is_some() {
            state.serialize_entry("urlMetadata", &self.url_metadata)?;
        }
        if self.browser.is_some() {
            state.serialize_entry("browser", &self.browser)?;
        }
        if !self.asset_id.is_empty() {
            state.serialize_entry("assetId", &self.asset_id)?;
        }
        if self.user.is_some() {
            state.serialize_entry("user", &self.user)?;
        }
        if !self.user_management_chain.is_empty() {
            state.serialize_entry("userManagementChain", &self.user_management_chain)?;
        }
        if self.group.is_some() {
            state.serialize_entry("group", &self.group)?;
        }
        if self.process.is_some() {
            state.serialize_entry("process", &self.process)?;
        }
        if !self.process_ancestors.is_empty() {
            state.serialize_entry("processAncestors", &self.process_ancestors)?;
        }
        if self.asset.is_some() {
            state.serialize_entry("asset", &self.asset)?;
        }
        if !self.ip.is_empty() {
            state.serialize_entry("ip", &self.ip)?;
        }
        if !self.nat_ip.is_empty() {
            state.serialize_entry("natIp", &self.nat_ip)?;
        }
        if !wkt::internal::is_default(&self.port) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("port", &__With(&self.port))?;
        }
        if !wkt::internal::is_default(&self.nat_port) {
            struct __With<'a>(&'a i32);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
                }
            }
            state.serialize_entry("natPort", &__With(&self.nat_port))?;
        }
        if !self.mac.is_empty() {
            state.serialize_entry("mac", &self.mac)?;
        }
        if !self.administrative_domain.is_empty() {
            state.serialize_entry("administrativeDomain", &self.administrative_domain)?;
        }
        if !self.namespace.is_empty() {
            state.serialize_entry("namespace", &self.namespace)?;
        }
        if !self.url.is_empty() {
            state.serialize_entry("url", &self.url)?;
        }
        if self.file.is_some() {
            state.serialize_entry("file", &self.file)?;
        }
        if !self.email.is_empty() {
            state.serialize_entry("email", &self.email)?;
        }
        if self.registry.is_some() {
            state.serialize_entry("registry", &self.registry)?;
        }
        if !self.application.is_empty() {
            state.serialize_entry("application", &self.application)?;
        }
        if !wkt::internal::is_default(&self.platform) {
            state.serialize_entry("platform", &self.platform)?;
        }
        if !self.platform_version.is_empty() {
            state.serialize_entry("platformVersion", &self.platform_version)?;
        }
        if !self.platform_patch_level.is_empty() {
            state.serialize_entry("platformPatchLevel", &self.platform_patch_level)?;
        }
        if self.cloud.is_some() {
            state.serialize_entry("cloud", &self.cloud)?;
        }
        if self.location.is_some() {
            state.serialize_entry("location", &self.location)?;
        }
        if !self.ip_location.is_empty() {
            state.serialize_entry("ipLocation", &self.ip_location)?;
        }
        if !self.ip_geo_artifact.is_empty() {
            state.serialize_entry("ipGeoArtifact", &self.ip_geo_artifact)?;
        }
        if self.resource.is_some() {
            state.serialize_entry("resource", &self.resource)?;
        }
        if !self.resource_ancestors.is_empty() {
            state.serialize_entry("resourceAncestors", &self.resource_ancestors)?;
        }
        if !self.labels.is_empty() {
            state.serialize_entry("labels", &self.labels)?;
        }
        if self.object_reference.is_some() {
            state.serialize_entry("objectReference", &self.object_reference)?;
        }
        if self.investigation.is_some() {
            state.serialize_entry("investigation", &self.investigation)?;
        }
        if self.network.is_some() {
            state.serialize_entry("network", &self.network)?;
        }
        if !self.security_result.is_empty() {
            state.serialize_entry("securityResult", &self.security_result)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Investigation {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if self.verdict.is_some() {
            state.serialize_entry("verdict", &self.verdict)?;
        }
        if self.reputation.is_some() {
            state.serialize_entry("reputation", &self.reputation)?;
        }
        if self.severity_score.is_some() {
            struct __With<'a>(&'a std::option::Option<u32>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("severityScore", &__With(&self.severity_score))?;
        }
        if self.status.is_some() {
            state.serialize_entry("status", &self.status)?;
        }
        if !self.comments.is_empty() {
            state.serialize_entry("comments", &self.comments)?;
        }
        if self.priority.is_some() {
            state.serialize_entry("priority", &self.priority)?;
        }
        if self.root_cause.is_some() {
            state.serialize_entry("rootCause", &self.root_cause)?;
        }
        if self.reason.is_some() {
            state.serialize_entry("reason", &self.reason)?;
        }
        if self.risk_score.is_some() {
            struct __With<'a>(&'a std::option::Option<u32>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::option::Option<wkt::internal::U32>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("riskScore", &__With(&self.risk_score))?;
        }
        if self.id.is_some() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Tags {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.tenant_id.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<::bytes::Bytes>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<serde_with::base64::Base64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("tenantId", &__With(&self.tenant_id))?;
        }
        if !self.data_tap_config_name.is_empty() {
            state.serialize_entry("dataTapConfigName", &self.data_tap_config_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::AttackDetails {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.version.is_empty() {
            state.serialize_entry("version", &self.version)?;
        }
        if !self.tactics.is_empty() {
            state.serialize_entry("tactics", &self.tactics)?;
        }
        if !self.techniques.is_empty() {
            state.serialize_entry("techniques", &self.techniques)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::attack_details::Tactic {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::attack_details::Technique {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.id.is_empty() {
            state.serialize_entry("id", &self.id)?;
        }
        if !self.name.is_empty() {
            state.serialize_entry("name", &self.name)?;
        }
        if !self.subtechnique_id.is_empty() {
            state.serialize_entry("subtechniqueId", &self.subtechnique_id)?;
        }
        if !self.subtechnique_name.is_empty() {
            state.serialize_entry("subtechniqueName", &self.subtechnique_name)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::BoolSequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.bool_vals.is_empty() {
            state.serialize_entry("boolVals", &self.bool_vals)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::BytesSequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.bytes_vals.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<::bytes::Bytes>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<serde_with::base64::Base64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("bytesVals", &__With(&self.bytes_vals))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::DoubleSequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.double_vals.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<f64>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<wkt::internal::F64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("doubleVals", &__With(&self.double_vals))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Int64Sequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.int64_vals.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<i64>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<wkt::internal::I64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("int64Vals", &__With(&self.int64_vals))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::Uint64Sequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.uint64_vals.is_empty() {
            struct __With<'a>(&'a std::vec::Vec<u64>);
            impl<'a> serde::ser::Serialize for __With<'a> {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::ser::Serializer,
                {
                    serde_with::As::<std::vec::Vec<wkt::internal::U64>>::serialize(
                        self.0, serializer,
                    )
                }
            }
            state.serialize_entry("uint64Vals", &__With(&self.uint64_vals))?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::StringSequence {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.string_vals.is_empty() {
            state.serialize_entry("stringVals", &self.string_vals)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}

#[doc(hidden)]
impl serde::ser::Serialize for super::GroupedFields {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeMap;
        #[allow(unused_imports)]
        use std::option::Option::Some;
        let mut state = serializer.serialize_map(std::option::Option::None)?;
        if !self.ip.is_empty() {
            state.serialize_entry("ip", &self.ip)?;
        }
        if !self.domain.is_empty() {
            state.serialize_entry("domain", &self.domain)?;
        }
        if !self.hostname.is_empty() {
            state.serialize_entry("hostname", &self.hostname)?;
        }
        if !self.user.is_empty() {
            state.serialize_entry("user", &self.user)?;
        }
        if !self.email.is_empty() {
            state.serialize_entry("email", &self.email)?;
        }
        if !self.file_path.is_empty() {
            state.serialize_entry("filePath", &self.file_path)?;
        }
        if !self.hash.is_empty() {
            state.serialize_entry("hash", &self.hash)?;
        }
        if !self.process_id.is_empty() {
            state.serialize_entry("processId", &self.process_id)?;
        }
        if !self._unknown_fields.is_empty() {
            for (key, value) in self._unknown_fields.iter() {
                state.serialize_entry(key, &value)?;
            }
        }
        state.end()
    }
}