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::*;

impl std::fmt::Debug for super::Collection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Collection");
        debug_struct.field("id", &self.id);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("id_namespace", &self.id_namespace);
        debug_struct.field("created_time", &self.created_time);
        debug_struct.field("last_updated_time", &self.last_updated_time);
        debug_struct.field("time_window", &self.time_window);
        debug_struct.field("collection_elements", &self.collection_elements);
        debug_struct.field("detection", &self.detection);
        debug_struct.field("detection_time", &self.detection_time);
        debug_struct.field("investigation", &self.investigation);
        debug_struct.field("tags", &self.tags);
        debug_struct.field("response_platform_info", &self.response_platform_info);
        debug_struct.field("case_name", &self.case_name);
        debug_struct.field("soar_alert", &self.soar_alert);
        debug_struct.field("soar_alert_metadata", &self.soar_alert_metadata);
        debug_struct.field("data_access_scope", &self.data_access_scope);
        debug_struct.field("detection_timing_details", &self.detection_timing_details);
        debug_struct.field("latency_metrics", &self.latency_metrics);
        debug_struct.field("rule_run_frequency", &self.rule_run_frequency);
        debug_struct.field("simulated_event_count", &self.simulated_event_count);
        debug_struct.field("simulated_event_names", &self.simulated_event_names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EntityGraphEnrichment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityGraphEnrichment");
        debug_struct.field("data_table", &self.data_table);
        debug_struct.field("enrichment_type", &self.enrichment_type);
        debug_struct.field("overridden_entity", &self.overridden_entity);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataTableRowInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataTableRowInfo");
        debug_struct.field("data_table", &self.data_table);
        debug_struct.field("row", &self.row);
        debug_struct.field("row_id", &self.row_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::LatencyMetrics {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LatencyMetrics");
        debug_struct.field("oldest_ingestion_time", &self.oldest_ingestion_time);
        debug_struct.field("newest_ingestion_time", &self.newest_ingestion_time);
        debug_struct.field("oldest_event_time", &self.oldest_event_time);
        debug_struct.field("newest_event_time", &self.newest_event_time);
        debug_struct.field("ingestion_latency", &self.ingestion_latency);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Reference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Reference");
        debug_struct.field("event", &self.event);
        debug_struct.field("entity", &self.entity);
        debug_struct.field("joined_data_table_rows", &self.joined_data_table_rows);
        debug_struct.field("graph_enrichment", &self.graph_enrichment);
        debug_struct.field("id", &self.id);
        debug_struct.field("log_batch_token", &self.log_batch_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Element {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Element");
        debug_struct.field("association", &self.association);
        debug_struct.field("references", &self.references);
        debug_struct.field("label", &self.label);
        debug_struct.field("references_sampled", &self.references_sampled);
        debug_struct.field("latency_metrics", &self.latency_metrics);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ResponsePlatformInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResponsePlatformInfo");
        debug_struct.field("alert_id", &self.alert_id);
        debug_struct.field("response_platform_type", &self.response_platform_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SoarAlertMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SoarAlertMetadata");
        debug_struct.field("alert_id", &self.alert_id);
        debug_struct.field("source_rule", &self.source_rule);
        debug_struct.field("vendor", &self.vendor);
        debug_struct.field("source_system", &self.source_system);
        debug_struct.field("product", &self.product);
        debug_struct.field("source_system_ticket_id", &self.source_system_ticket_id);
        debug_struct.field("source_system_uri", &self.source_system_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataAccessIngestionLabel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataAccessIngestionLabel");
        debug_struct.field("key", &self.key);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DataAccessLabels {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DataAccessLabels");
        debug_struct.field("log_types", &self.log_types);
        debug_struct.field("ingestion_labels", &self.ingestion_labels);
        debug_struct.field("namespaces", &self.namespaces);
        debug_struct.field("custom_labels", &self.custom_labels);
        debug_struct.field("ingestion_kv_labels", &self.ingestion_kv_labels);
        debug_struct.field("allow_scoped_access", &self.allow_scoped_access);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EntityMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityMetadata");
        debug_struct.field("product_entity_id", &self.product_entity_id);
        debug_struct.field("collected_timestamp", &self.collected_timestamp);
        debug_struct.field("creation_timestamp", &self.creation_timestamp);
        debug_struct.field("interval", &self.interval);
        debug_struct.field("vendor_name", &self.vendor_name);
        debug_struct.field("product_name", &self.product_name);
        debug_struct.field("feed", &self.feed);
        debug_struct.field("product_version", &self.product_version);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("description", &self.description);
        debug_struct.field("threat", &self.threat);
        debug_struct.field("source_type", &self.source_type);
        debug_struct.field("source_labels", &self.source_labels);
        debug_struct.field("event_metadata", &self.event_metadata);
        debug_struct.field("structured_fields", &self.structured_fields);
        debug_struct.field("extracted", &self.extracted);
        debug_struct.field("ati_prioritization", &self.ati_prioritization);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AtiPrioritization {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AtiPrioritization");
        debug_struct.field("gti_verdict", &self.gti_verdict);
        debug_struct.field("gti_severity", &self.gti_severity);
        debug_struct.field("gti_threat_score", &self.gti_threat_score);
        debug_struct.field(
            "mandiant_analyst_confidence",
            &self.mandiant_analyst_confidence,
        );
        debug_struct.field("gti_update_time", &self.gti_update_time);
        debug_struct.field("active_ir", &self.active_ir);
        debug_struct.field(
            "active_ir_first_tagged_time",
            &self.active_ir_first_tagged_time,
        );
        debug_struct.field("global_customer_count", &self.global_customer_count);
        debug_struct.field("global_hit_count", &self.global_hit_count);
        debug_struct.field("exclusive", &self.exclusive);
        debug_struct.field("osint", &self.osint);
        debug_struct.field("scanner", &self.scanner);
        debug_struct.field("reviewed", &self.reviewed);
        debug_struct.field("attributed_malware", &self.attributed_malware);
        debug_struct.field("attributed_threat_actors", &self.attributed_threat_actors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Entity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Entity");
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("entity", &self.entity);
        debug_struct.field("relations", &self.relations);
        debug_struct.field("additional", &self.additional);
        debug_struct.field("risk_score", &self.risk_score);
        debug_struct.field("metric", &self.metric);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Relation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Relation");
        debug_struct.field("entity", &self.entity);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("relationship", &self.relationship);
        debug_struct.field("direction", &self.direction);
        debug_struct.field("uid", &self.uid);
        debug_struct.field("entity_label", &self.entity_label);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Metric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Metric");
        debug_struct.field("first_seen", &self.first_seen);
        debug_struct.field("last_seen", &self.last_seen);
        debug_struct.field("sum_measure", &self.sum_measure);
        debug_struct.field("total_events", &self.total_events);
        debug_struct.field("metric_name", &self.metric_name);
        debug_struct.field("dimensions", &self.dimensions);
        debug_struct.field("export_window", &self.export_window);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("outcome_variables", &self.outcome_variables);
        debug_struct.field("match_variables", &self.match_variables);
        debug_struct.field("time_range", &self.time_range);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::metric::Measure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Measure");
        debug_struct.field("value", &self.value);
        debug_struct.field("aggregate_function", &self.aggregate_function);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EntityRisk {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityRisk");
        debug_struct.field("risk_version", &self.risk_version);
        debug_struct.field("risk_window", &self.risk_window);
        debug_struct.field("deprecated_risk_score", &self.deprecated_risk_score);
        debug_struct.field("risk_delta", &self.risk_delta);
        debug_struct.field("detections_count", &self.detections_count);
        debug_struct.field("first_detection_time", &self.first_detection_time);
        debug_struct.field("last_detection_time", &self.last_detection_time);
        debug_struct.field("risk_score", &self.risk_score);
        debug_struct.field("normalized_risk_score", &self.normalized_risk_score);
        debug_struct.field("risk_window_size", &self.risk_window_size);
        debug_struct.field("raw_risk_delta", &self.raw_risk_delta);
        debug_struct.field("last_reset_time", &self.last_reset_time);
        debug_struct.field("detail_uri", &self.detail_uri);
        debug_struct.field(
            "risk_window_has_new_detections",
            &self.risk_window_has_new_detections,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RiskDelta {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RiskDelta");
        debug_struct.field("previous_range_end_time", &self.previous_range_end_time);
        debug_struct.field("risk_score_delta", &self.risk_score_delta);
        debug_struct.field("previous_risk_score", &self.previous_risk_score);
        debug_struct.field("risk_score_numeric_delta", &self.risk_score_numeric_delta);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Id {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Id");
        debug_struct.field("namespace", &self.namespace);
        debug_struct.field("id", &self.id);
        debug_struct.field("string_id", &self.string_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Udm {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Udm");
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("additional", &self.additional);
        debug_struct.field("principal", &self.principal);
        debug_struct.field("src", &self.src);
        debug_struct.field("target", &self.target);
        debug_struct.field("intermediary", &self.intermediary);
        debug_struct.field("observer", &self.observer);
        debug_struct.field("about", &self.about);
        debug_struct.field("security_result", &self.security_result);
        debug_struct.field("network", &self.network);
        debug_struct.field("extensions", &self.extensions);
        debug_struct.field("extracted", &self.extracted);
        debug_struct.field("grouped", &self.grouped);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Metadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Metadata");
        debug_struct.field("id", &self.id);
        debug_struct.field("product_log_id", &self.product_log_id);
        debug_struct.field("event_timestamp", &self.event_timestamp);
        debug_struct.field(
            "event_timestamp_attributes",
            &self.event_timestamp_attributes,
        );
        debug_struct.field("collected_timestamp", &self.collected_timestamp);
        debug_struct.field("ingested_timestamp", &self.ingested_timestamp);
        debug_struct.field("event_type", &self.event_type);
        debug_struct.field("vendor_name", &self.vendor_name);
        debug_struct.field("product_name", &self.product_name);
        debug_struct.field("product_version", &self.product_version);
        debug_struct.field("product_event_type", &self.product_event_type);
        debug_struct.field("product_deployment_id", &self.product_deployment_id);
        debug_struct.field("description", &self.description);
        debug_struct.field("url_back_to_product", &self.url_back_to_product);
        debug_struct.field("ingestion_labels", &self.ingestion_labels);
        debug_struct.field("tags", &self.tags);
        debug_struct.field("enrichment_state", &self.enrichment_state);
        debug_struct.field("log_type", &self.log_type);
        debug_struct.field("base_labels", &self.base_labels);
        debug_struct.field("enrichment_labels", &self.enrichment_labels);
        debug_struct.field("structured_fields", &self.structured_fields);
        debug_struct.field("parser_version", &self.parser_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Attribute {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Attribute");
        debug_struct.field("cloud", &self.cloud);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("permissions", &self.permissions);
        debug_struct.field("roles", &self.roles);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("last_update_time", &self.last_update_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Network {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Network");
        debug_struct.field("sent_bytes", &self.sent_bytes);
        debug_struct.field("received_bytes", &self.received_bytes);
        debug_struct.field("total_bytes", &self.total_bytes);
        debug_struct.field("sent_packets", &self.sent_packets);
        debug_struct.field("received_packets", &self.received_packets);
        debug_struct.field("session_duration", &self.session_duration);
        debug_struct.field("session_id", &self.session_id);
        debug_struct.field("parent_session_id", &self.parent_session_id);
        debug_struct.field(
            "application_protocol_version",
            &self.application_protocol_version,
        );
        debug_struct.field("community_id", &self.community_id);
        debug_struct.field("direction", &self.direction);
        debug_struct.field("ip_protocol", &self.ip_protocol);
        debug_struct.field("ipv6", &self.ipv6);
        debug_struct.field("application_protocol", &self.application_protocol);
        debug_struct.field("ftp", &self.ftp);
        debug_struct.field("email", &self.email);
        debug_struct.field("dns", &self.dns);
        debug_struct.field("dhcp", &self.dhcp);
        debug_struct.field("http", &self.http);
        debug_struct.field("tls", &self.tls);
        debug_struct.field("smtp", &self.smtp);
        debug_struct.field("asn", &self.asn);
        debug_struct.field("dns_domain", &self.dns_domain);
        debug_struct.field("carrier_name", &self.carrier_name);
        debug_struct.field("organization_name", &self.organization_name);
        debug_struct.field("ip_subnet_range", &self.ip_subnet_range);
        debug_struct.field("is_proxy", &self.is_proxy);
        debug_struct.field("proxy_info", &self.proxy_info);
        debug_struct.field("connection_state", &self.connection_state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ProxyInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProxyInfo");
        debug_struct.field("anonymous", &self.anonymous);
        debug_struct.field("anonymous_vpn", &self.anonymous_vpn);
        debug_struct.field("public_proxy", &self.public_proxy);
        debug_struct.field("tor_exit_node", &self.tor_exit_node);
        debug_struct.field("smart_dns_proxy", &self.smart_dns_proxy);
        debug_struct.field("hosting_provider", &self.hosting_provider);
        debug_struct.field("vpn_datacenter", &self.vpn_datacenter);
        debug_struct.field("residential_proxy", &self.residential_proxy);
        debug_struct.field("vpn_service_name", &self.vpn_service_name);
        debug_struct.field("proxy_over_vpn", &self.proxy_over_vpn);
        debug_struct.field("relay_proxy", &self.relay_proxy);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Extensions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Extensions");
        debug_struct.field("auth", &self.auth);
        debug_struct.field("vulns", &self.vulns);
        debug_struct.field("entity_risk", &self.entity_risk);
        debug_struct.field("linux_utmp", &self.linux_utmp);
        debug_struct.field("windows_event_log", &self.windows_event_log);
        debug_struct.field("resource_usage", &self.resource_usage);
        debug_struct.field("system_event_details", &self.system_event_details);
        debug_struct.field("outlook_metadata", &self.outlook_metadata);
        debug_struct.field("srum", &self.srum);
        debug_struct.field("user_assist", &self.user_assist);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Authentication {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Authentication");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("mechanism", &self.mechanism);
        debug_struct.field("auth_details", &self.auth_details);
        debug_struct.field("outcome", &self.outcome);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::LinuxUtmp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LinuxUtmp");
        debug_struct.field("record_type", &self.record_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::WindowsEventLog {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WindowsEventLog");
        debug_struct.field("channel", &self.channel);
        debug_struct.field("event_id", &self.event_id);
        debug_struct.field("activity_id", &self.activity_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ResourceUsage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceUsage");
        debug_struct.field("used_entity", &self.used_entity);
        debug_struct.field("used_entity_id", &self.used_entity_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SystemEventDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SystemEventDetails");
        debug_struct.field("message_type", &self.message_type);
        debug_struct.field("sender_image_id", &self.sender_image_id);
        debug_struct.field("subsystem", &self.subsystem);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::OutlookMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutlookMetadata");
        debug_struct.field("comment", &self.comment);
        debug_struct.field("template", &self.template);
        debug_struct.field("title", &self.title);
        debug_struct.field("security_flags_count", &self.security_flags_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Srum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Srum");
        debug_struct.field("id", &self.id);
        debug_struct.field("background_bytes_read", &self.background_bytes_read);
        debug_struct.field("background_bytes_written", &self.background_bytes_written);
        debug_struct.field(
            "background_context_switches",
            &self.background_context_switches,
        );
        debug_struct.field("background_cycle_count", &self.background_cycle_count);
        debug_struct.field("background_flushes_count", &self.background_flushes_count);
        debug_struct.field(
            "background_read_operations",
            &self.background_read_operations,
        );
        debug_struct.field(
            "background_write_operations",
            &self.background_write_operations,
        );
        debug_struct.field("interface_luid", &self.interface_luid);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::UserAssist {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UserAssist");
        debug_struct.field("application_focus_count", &self.application_focus_count);
        debug_struct.field(
            "application_focus_duration",
            &self.application_focus_duration,
        );
        debug_struct.field("executions_count", &self.executions_count);
        debug_struct.field("entry_index", &self.entry_index);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Vulnerabilities {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Vulnerabilities");
        debug_struct.field("vulnerabilities", &self.vulnerabilities);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Vulnerability {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Vulnerability");
        debug_struct.field("about", &self.about);
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("vendor", &self.vendor);
        debug_struct.field("scan_start_time", &self.scan_start_time);
        debug_struct.field("scan_end_time", &self.scan_end_time);
        debug_struct.field("first_found", &self.first_found);
        debug_struct.field("last_found", &self.last_found);
        debug_struct.field("severity", &self.severity);
        debug_struct.field("severity_details", &self.severity_details);
        debug_struct.field("cvss_base_score", &self.cvss_base_score);
        debug_struct.field("cvss_vector", &self.cvss_vector);
        debug_struct.field("cvss_version", &self.cvss_version);
        debug_struct.field("cve_id", &self.cve_id);
        debug_struct.field("cve_description", &self.cve_description);
        debug_struct.field("vendor_vulnerability_id", &self.vendor_vulnerability_id);
        debug_struct.field(
            "vendor_knowledge_base_article_id",
            &self.vendor_knowledge_base_article_id,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Ftp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Ftp");
        debug_struct.field("command", &self.command);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Smtp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Smtp");
        debug_struct.field("helo", &self.helo);
        debug_struct.field("mail_from", &self.mail_from);
        debug_struct.field("rcpt_to", &self.rcpt_to);
        debug_struct.field("server_response", &self.server_response);
        debug_struct.field("message_path", &self.message_path);
        debug_struct.field("is_webmail", &self.is_webmail);
        debug_struct.field("is_tls", &self.is_tls);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Email {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Email");
        debug_struct.field("from", &self.from);
        debug_struct.field("reply_to", &self.reply_to);
        debug_struct.field("to", &self.to);
        debug_struct.field("cc", &self.cc);
        debug_struct.field("bcc", &self.bcc);
        debug_struct.field("mail_id", &self.mail_id);
        debug_struct.field("subject", &self.subject);
        debug_struct.field("bounce_address", &self.bounce_address);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Process {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Process");
        debug_struct.field("pid", &self.pid);
        debug_struct.field("parent_pid", &self.parent_pid);
        debug_struct.field("parent_process", &self.parent_process);
        debug_struct.field("file", &self.file);
        debug_struct.field("command_line", &self.command_line);
        debug_struct.field("command_line_history", &self.command_line_history);
        debug_struct.field(
            "product_specific_process_id",
            &self.product_specific_process_id,
        );
        debug_struct.field("access_mask", &self.access_mask);
        debug_struct.field("integrity_level_rid", &self.integrity_level_rid);
        debug_struct.field("euid", &self.euid);
        debug_struct.field("ruid", &self.ruid);
        debug_struct.field("egid", &self.egid);
        debug_struct.field("rgid", &self.rgid);
        debug_struct.field("pgid", &self.pgid);
        debug_struct.field("session_leader_pid", &self.session_leader_pid);
        debug_struct.field("tty", &self.tty);
        debug_struct.field("token_elevation_type", &self.token_elevation_type);
        debug_struct.field(
            "product_specific_parent_process_id",
            &self.product_specific_parent_process_id,
        );
        debug_struct.field("ipv6", &self.ipv6);
        debug_struct.field("kernel_duration", &self.kernel_duration);
        debug_struct.field("user_duration", &self.user_duration);
        debug_struct.field("real_duration", &self.real_duration);
        debug_struct.field("state", &self.state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AnalyticsMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnalyticsMetadata");
        debug_struct.field("analytic", &self.analytic);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FindingVariable {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FindingVariable");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("value", &self.value);
        debug_struct.field("source_path", &self.source_path);
        debug_struct.field("typed_value", &self.typed_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SecurityResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SecurityResult");
        debug_struct.field("about", &self.about);
        debug_struct.field("category", &self.category);
        debug_struct.field("category_details", &self.category_details);
        debug_struct.field("threat_name", &self.threat_name);
        debug_struct.field("rule_set", &self.rule_set);
        debug_struct.field("rule_set_display_name", &self.rule_set_display_name);
        debug_struct.field(
            "ruleset_category_display_name",
            &self.ruleset_category_display_name,
        );
        debug_struct.field("rule_id", &self.rule_id);
        debug_struct.field("rule_name", &self.rule_name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("rule_version", &self.rule_version);
        debug_struct.field("rule_type", &self.rule_type);
        debug_struct.field("rule_author", &self.rule_author);
        debug_struct.field("rule_labels", &self.rule_labels);
        debug_struct.field("alert_state", &self.alert_state);
        debug_struct.field("detection_fields", &self.detection_fields);
        debug_struct.field("outcomes", &self.outcomes);
        debug_struct.field("variables", &self.variables);
        debug_struct.field("summary", &self.summary);
        debug_struct.field("description", &self.description);
        debug_struct.field("action", &self.action);
        debug_struct.field("action_details", &self.action_details);
        debug_struct.field("severity", &self.severity);
        debug_struct.field("confidence", &self.confidence);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("risk_score", &self.risk_score);
        debug_struct.field("confidence_score", &self.confidence_score);
        debug_struct.field("analytics_metadata", &self.analytics_metadata);
        debug_struct.field("severity_details", &self.severity_details);
        debug_struct.field("confidence_details", &self.confidence_details);
        debug_struct.field("priority_details", &self.priority_details);
        debug_struct.field("url_back_to_product", &self.url_back_to_product);
        debug_struct.field("threat_id", &self.threat_id);
        debug_struct.field("threat_feed_name", &self.threat_feed_name);
        debug_struct.field("threat_id_namespace", &self.threat_id_namespace);
        debug_struct.field("threat_status", &self.threat_status);
        debug_struct.field("attack_details", &self.attack_details);
        debug_struct.field("first_discovered_time", &self.first_discovered_time);
        debug_struct.field("associations", &self.associations);
        debug_struct.field("campaigns", &self.campaigns);
        debug_struct.field("reports", &self.reports);
        debug_struct.field("verdict", &self.verdict);
        debug_struct.field("last_updated_time", &self.last_updated_time);
        debug_struct.field("verdict_info", &self.verdict_info);
        debug_struct.field("threat_verdict", &self.threat_verdict);
        debug_struct.field("last_discovered_time", &self.last_discovered_time);
        debug_struct.field("detection_depth", &self.detection_depth);
        debug_struct.field("threat_collections", &self.threat_collections);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::Association {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Association");
        debug_struct.field("id", &self.id);
        debug_struct.field("country_code", &self.country_code);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("role", &self.role);
        debug_struct.field("source_country", &self.source_country);
        debug_struct.field("alias", &self.alias);
        debug_struct.field("first_reference_time", &self.first_reference_time);
        debug_struct.field("last_reference_time", &self.last_reference_time);
        debug_struct.field("industries_affected", &self.industries_affected);
        debug_struct.field("associated_actors", &self.associated_actors);
        debug_struct.field("region_code", &self.region_code);
        debug_struct.field("sponsor_region", &self.sponsor_region);
        debug_struct.field("targeted_regions", &self.targeted_regions);
        debug_struct.field("tags", &self.tags);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::association::AssociationAlias {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssociationAlias");
        debug_struct.field("name", &self.name);
        debug_struct.field("company", &self.company);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::Source {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Source");
        debug_struct.field("name", &self.name);
        debug_struct.field("benign_count", &self.benign_count);
        debug_struct.field("malicious_count", &self.malicious_count);
        debug_struct.field("quality", &self.quality);
        debug_struct.field("response_count", &self.response_count);
        debug_struct.field("source_count", &self.source_count);
        debug_struct.field(
            "threat_intelligence_sources",
            &self.threat_intelligence_sources,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::ProviderMLVerdict {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProviderMLVerdict");
        debug_struct.field("source_provider", &self.source_provider);
        debug_struct.field("benign_count", &self.benign_count);
        debug_struct.field("malicious_count", &self.malicious_count);
        debug_struct.field("confidence_score", &self.confidence_score);
        debug_struct.field("mandiant_sources", &self.mandiant_sources);
        debug_struct.field("third_party_sources", &self.third_party_sources);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::AnalystVerdict {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnalystVerdict");
        debug_struct.field("confidence_score", &self.confidence_score);
        debug_struct.field("verdict_time", &self.verdict_time);
        debug_struct.field("verdict_response", &self.verdict_response);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::IoCStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IoCStats");
        debug_struct.field("ioc_stats_type", &self.ioc_stats_type);
        debug_struct.field("first_level_source", &self.first_level_source);
        debug_struct.field("second_level_source", &self.second_level_source);
        debug_struct.field("benign_count", &self.benign_count);
        debug_struct.field("quality", &self.quality);
        debug_struct.field("malicious_count", &self.malicious_count);
        debug_struct.field("response_count", &self.response_count);
        debug_struct.field("source_count", &self.source_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::VerdictInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VerdictInfo");
        debug_struct.field("source_count", &self.source_count);
        debug_struct.field("response_count", &self.response_count);
        debug_struct.field("neighbour_influence", &self.neighbour_influence);
        debug_struct.field("verdict_type", &self.verdict_type);
        debug_struct.field("source_provider", &self.source_provider);
        debug_struct.field("benign_count", &self.benign_count);
        debug_struct.field("malicious_count", &self.malicious_count);
        debug_struct.field("confidence_score", &self.confidence_score);
        debug_struct.field("ioc_stats", &self.ioc_stats);
        debug_struct.field("verdict_time", &self.verdict_time);
        debug_struct.field("verdict_response", &self.verdict_response);
        debug_struct.field("global_customer_count", &self.global_customer_count);
        debug_struct.field("global_hits_count", &self.global_hits_count);
        debug_struct.field("pwn", &self.pwn);
        debug_struct.field("category_details", &self.category_details);
        debug_struct.field("pwn_first_tagged_time", &self.pwn_first_tagged_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::Verdict {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Verdict");
        debug_struct.field("source_count", &self.source_count);
        debug_struct.field("response_count", &self.response_count);
        debug_struct.field("neighbour_influence", &self.neighbour_influence);
        debug_struct.field("verdict", &self.verdict);
        debug_struct.field("analyst_verdict", &self.analyst_verdict);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::security_result::ThreatCollectionItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ThreatCollectionItem");
        debug_struct.field("id", &self.id);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("alt_names", &self.alt_names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PeFileMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PeFileMetadata");
        debug_struct.field("import_hash", &self.import_hash);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadata");
        debug_struct.field("pe", &self.pe);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::File {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("File");
        debug_struct.field("sha256", &self.sha256);
        debug_struct.field("md5", &self.md5);
        debug_struct.field("sha1", &self.sha1);
        debug_struct.field("size", &self.size);
        debug_struct.field("full_path", &self.full_path);
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("file_metadata", &self.file_metadata);
        debug_struct.field("security_result", &self.security_result);
        debug_struct.field("pe_file", &self.pe_file);
        debug_struct.field("ssdeep", &self.ssdeep);
        debug_struct.field("vhash", &self.vhash);
        debug_struct.field("ahash", &self.ahash);
        debug_struct.field("authentihash", &self.authentihash);
        debug_struct.field("symhash", &self.symhash);
        debug_struct.field("prefetch_file_metadata", &self.prefetch_file_metadata);
        debug_struct.field("file_type", &self.file_type);
        debug_struct.field("capabilities_tags", &self.capabilities_tags);
        debug_struct.field("names", &self.names);
        debug_struct.field("tags", &self.tags);
        debug_struct.field("last_modification_time", &self.last_modification_time);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("last_access_time", &self.last_access_time);
        debug_struct.field("prevalence", &self.prevalence);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("last_seen_time", &self.last_seen_time);
        debug_struct.field("stat_mode", &self.stat_mode);
        debug_struct.field("stat_inode", &self.stat_inode);
        debug_struct.field("stat_dev", &self.stat_dev);
        debug_struct.field("stat_nlink", &self.stat_nlink);
        debug_struct.field("stat_flags", &self.stat_flags);
        debug_struct.field("last_analysis_time", &self.last_analysis_time);
        debug_struct.field("embedded_urls", &self.embedded_urls);
        debug_struct.field("embedded_domains", &self.embedded_domains);
        debug_struct.field("embedded_ips", &self.embedded_ips);
        debug_struct.field("exif_info", &self.exif_info);
        debug_struct.field("signature_info", &self.signature_info);
        debug_struct.field("pdf_info", &self.pdf_info);
        debug_struct.field("first_submission_time", &self.first_submission_time);
        debug_struct.field("last_submission_time", &self.last_submission_time);
        debug_struct.field("main_icon", &self.main_icon);
        debug_struct.field("ntfs", &self.ntfs);
        debug_struct.field("app_compat_cache", &self.app_compat_cache);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::NtfsFileMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NtfsFileMetadata");
        debug_struct.field("change_time", &self.change_time);
        debug_struct.field("filename_create_time", &self.filename_create_time);
        debug_struct.field("filename_modify_time", &self.filename_modify_time);
        debug_struct.field("filename_access_time", &self.filename_access_time);
        debug_struct.field("filename_change_time", &self.filename_change_time);
        debug_struct.field("usn_journal", &self.usn_journal);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PrefetchFileMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PrefetchFileMetadata");
        debug_struct.field("run_count", &self.run_count);
        debug_struct.field("prefetch_hash", &self.prefetch_hash);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::UsnJournal {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UsnJournal");
        debug_struct.field("attributes_flag", &self.attributes_flag);
        debug_struct.field("attributes", &self.attributes);
        debug_struct.field("file_attributes", &self.file_attributes);
        debug_struct.field("allocated", &self.allocated);
        debug_struct.field("reason", &self.reason);
        debug_struct.field("reasons", &self.reasons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AppCompatMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AppCompatMetadata");
        debug_struct.field("sequence", &self.sequence);
        debug_struct.field("executed", &self.executed);
        debug_struct.field("control_set", &self.control_set);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataPE {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataPE");
        debug_struct.field("imphash", &self.imphash);
        debug_struct.field("entry_point", &self.entry_point);
        debug_struct.field("entry_point_exiftool", &self.entry_point_exiftool);
        debug_struct.field("compilation_time", &self.compilation_time);
        debug_struct.field("compilation_exiftool_time", &self.compilation_exiftool_time);
        debug_struct.field("section", &self.section);
        debug_struct.field("imports", &self.imports);
        debug_struct.field("resource", &self.resource);
        debug_struct.field("resources_type_count", &self.resources_type_count);
        debug_struct.field("resources_language_count", &self.resources_language_count);
        debug_struct.field("resources_type_count_str", &self.resources_type_count_str);
        debug_struct.field(
            "resources_language_count_str",
            &self.resources_language_count_str,
        );
        debug_struct.field("signature_info", &self.signature_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataPeResourceInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataPeResourceInfo");
        debug_struct.field("sha256_hex", &self.sha256_hex);
        debug_struct.field("filetype_magic", &self.filetype_magic);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("entropy", &self.entropy);
        debug_struct.field("file_type", &self.file_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SignatureInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SignatureInfo");
        debug_struct.field("sigcheck", &self.sigcheck);
        debug_struct.field("codesign", &self.codesign);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataSignatureInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataSignatureInfo");
        debug_struct.field("verification_message", &self.verification_message);
        debug_struct.field("verified", &self.verified);
        debug_struct.field("signer", &self.signer);
        debug_struct.field("signers", &self.signers);
        debug_struct.field("x509", &self.x509);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SignerInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SignerInfo");
        debug_struct.field("name", &self.name);
        debug_struct.field("status", &self.status);
        debug_struct.field("valid_usage", &self.valid_usage);
        debug_struct.field("cert_issuer", &self.cert_issuer);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataCodesign {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataCodesign");
        debug_struct.field("id", &self.id);
        debug_struct.field("format", &self.format);
        debug_struct.field("compilation_time", &self.compilation_time);
        debug_struct.field("team_id", &self.team_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::X509 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("X509");
        debug_struct.field("name", &self.name);
        debug_struct.field("algorithm", &self.algorithm);
        debug_struct.field("thumbprint", &self.thumbprint);
        debug_struct.field("cert_issuer", &self.cert_issuer);
        debug_struct.field("serial_number", &self.serial_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PDFInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PDFInfo");
        debug_struct.field("js", &self.js);
        debug_struct.field("javascript", &self.javascript);
        debug_struct.field("launch_action_count", &self.launch_action_count);
        debug_struct.field("object_stream_count", &self.object_stream_count);
        debug_struct.field("endobj_count", &self.endobj_count);
        debug_struct.field("header", &self.header);
        debug_struct.field("acroform", &self.acroform);
        debug_struct.field("autoaction", &self.autoaction);
        debug_struct.field("embedded_file", &self.embedded_file);
        debug_struct.field("encrypted", &self.encrypted);
        debug_struct.field("flash", &self.flash);
        debug_struct.field("jbig2_compression", &self.jbig2_compression);
        debug_struct.field("obj_count", &self.obj_count);
        debug_struct.field("endstream_count", &self.endstream_count);
        debug_struct.field("page_count", &self.page_count);
        debug_struct.field("stream_count", &self.stream_count);
        debug_struct.field("openaction", &self.openaction);
        debug_struct.field("startxref", &self.startxref);
        debug_struct.field("suspicious_colors", &self.suspicious_colors);
        debug_struct.field("trailer", &self.trailer);
        debug_struct.field("xfa", &self.xfa);
        debug_struct.field("xref", &self.xref);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StringToInt64MapEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StringToInt64MapEntry");
        debug_struct.field("key", &self.key);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataSection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataSection");
        debug_struct.field("name", &self.name);
        debug_struct.field("entropy", &self.entropy);
        debug_struct.field("raw_size_bytes", &self.raw_size_bytes);
        debug_struct.field("virtual_size_bytes", &self.virtual_size_bytes);
        debug_struct.field("md5_hex", &self.md5_hex);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::FileMetadataImports {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FileMetadataImports");
        debug_struct.field("library", &self.library);
        debug_struct.field("functions", &self.functions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ExifInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExifInfo");
        debug_struct.field("original_file", &self.original_file);
        debug_struct.field("product", &self.product);
        debug_struct.field("company", &self.company);
        debug_struct.field("file_description", &self.file_description);
        debug_struct.field("entry_point", &self.entry_point);
        debug_struct.field("compilation_time", &self.compilation_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Prevalence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Prevalence");
        debug_struct.field("rolling_max", &self.rolling_max);
        debug_struct.field("day_count", &self.day_count);
        debug_struct.field("rolling_max_sub_domains", &self.rolling_max_sub_domains);
        debug_struct.field("day_max", &self.day_max);
        debug_struct.field("day_max_sub_domains", &self.day_max_sub_domains);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Dns {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Dns");
        debug_struct.field("id", &self.id);
        debug_struct.field("response", &self.response);
        debug_struct.field("opcode", &self.opcode);
        debug_struct.field("authoritative", &self.authoritative);
        debug_struct.field("truncated", &self.truncated);
        debug_struct.field("recursion_desired", &self.recursion_desired);
        debug_struct.field("recursion_available", &self.recursion_available);
        debug_struct.field("response_code", &self.response_code);
        debug_struct.field("questions", &self.questions);
        debug_struct.field("answers", &self.answers);
        debug_struct.field("authority", &self.authority);
        debug_struct.field("additional", &self.additional);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::dns::Question {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Question");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("class", &self.class);
        debug_struct.field("prevalence", &self.prevalence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::dns::ResourceRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceRecord");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("class", &self.class);
        debug_struct.field("ttl", &self.ttl);
        debug_struct.field("data", &self.data);
        debug_struct.field("binary_data", &self.binary_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Dhcp {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Dhcp");
        debug_struct.field("opcode", &self.opcode);
        debug_struct.field("htype", &self.htype);
        debug_struct.field("hlen", &self.hlen);
        debug_struct.field("hops", &self.hops);
        debug_struct.field("transaction_id", &self.transaction_id);
        debug_struct.field("seconds", &self.seconds);
        debug_struct.field("flags", &self.flags);
        debug_struct.field("ciaddr", &self.ciaddr);
        debug_struct.field("yiaddr", &self.yiaddr);
        debug_struct.field("siaddr", &self.siaddr);
        debug_struct.field("giaddr", &self.giaddr);
        debug_struct.field("chaddr", &self.chaddr);
        debug_struct.field("sname", &self.sname);
        debug_struct.field("file", &self.file);
        debug_struct.field("options", &self.options);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("lease_time_seconds", &self.lease_time_seconds);
        debug_struct.field("client_hostname", &self.client_hostname);
        debug_struct.field("client_identifier", &self.client_identifier);
        debug_struct.field("requested_address", &self.requested_address);
        debug_struct.field("client_identifier_string", &self.client_identifier_string);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::dhcp::Option {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Option");
        debug_struct.field("code", &self.code);
        debug_struct.field("data", &self.data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Certificate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Certificate");
        debug_struct.field("version", &self.version);
        debug_struct.field("serial", &self.serial);
        debug_struct.field("subject", &self.subject);
        debug_struct.field("issuer", &self.issuer);
        debug_struct.field("md5", &self.md5);
        debug_struct.field("sha1", &self.sha1);
        debug_struct.field("sha256", &self.sha256);
        debug_struct.field("not_before", &self.not_before);
        debug_struct.field("not_after", &self.not_after);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Tls {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tls");
        debug_struct.field("client", &self.client);
        debug_struct.field("server", &self.server);
        debug_struct.field("cipher", &self.cipher);
        debug_struct.field("curve", &self.curve);
        debug_struct.field("version", &self.version);
        debug_struct.field("version_protocol", &self.version_protocol);
        debug_struct.field("established", &self.established);
        debug_struct.field("next_protocol", &self.next_protocol);
        debug_struct.field("resumed", &self.resumed);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::tls::Client {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Client");
        debug_struct.field("certificate", &self.certificate);
        debug_struct.field("ja3", &self.ja3);
        debug_struct.field("server_name", &self.server_name);
        debug_struct.field("supported_ciphers", &self.supported_ciphers);
        debug_struct.field("ja4", &self.ja4);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::tls::Server {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Server");
        debug_struct.field("certificate", &self.certificate);
        debug_struct.field("ja3s", &self.ja3s);
        debug_struct.field("ja4s", &self.ja4s);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Http {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Http");
        debug_struct.field("method", &self.method);
        debug_struct.field("referral_url", &self.referral_url);
        debug_struct.field("user_agent", &self.user_agent);
        debug_struct.field("response_code", &self.response_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Browser {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Browser");
        debug_struct.field("browser_type", &self.browser_type);
        debug_struct.field("browser_version", &self.browser_version);
        debug_struct.field("first_visit_time", &self.first_visit_time);
        debug_struct.field("last_visit_time", &self.last_visit_time);
        debug_struct.field("profile", &self.profile);
        debug_struct.field("typed", &self.typed);
        debug_struct.field("visit_type", &self.visit_type);
        debug_struct.field("hidden", &self.hidden);
        debug_struct.field("request_origin_uri", &self.request_origin_uri);
        debug_struct.field("visit_count", &self.visit_count);
        debug_struct.field("visit_count_criteria", &self.visit_count_criteria);
        debug_struct.field("indexed_content", &self.indexed_content);
        debug_struct.field("first_bookmarked_time", &self.first_bookmarked_time);
        debug_struct.field("cookies", &self.cookies);
        debug_struct.field("typed_count", &self.typed_count);
        debug_struct.field("visit_source", &self.visit_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::browser::Cookie {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Cookie");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        debug_struct.field("domain", &self.domain);
        debug_struct.field("path", &self.path);
        debug_struct.field("expiration_time", &self.expiration_time);
        debug_struct.field("http_only", &self.http_only);
        debug_struct.field("secure", &self.secure);
        debug_struct.field("max_age", &self.max_age);
        debug_struct.field("same_site", &self.same_site);
        debug_struct.field("session", &self.session);
        debug_struct.field("partitioned", &self.partitioned);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Hardware {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Hardware");
        debug_struct.field("serial_number", &self.serial_number);
        debug_struct.field("manufacturer", &self.manufacturer);
        debug_struct.field("model", &self.model);
        debug_struct.field("cpu_platform", &self.cpu_platform);
        debug_struct.field("cpu_model", &self.cpu_model);
        debug_struct.field("cpu_clock_speed", &self.cpu_clock_speed);
        debug_struct.field("cpu_max_clock_speed", &self.cpu_max_clock_speed);
        debug_struct.field("cpu_number_cores", &self.cpu_number_cores);
        debug_struct.field("ram", &self.ram);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PlatformSoftware {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PlatformSoftware");
        debug_struct.field("platform", &self.platform);
        debug_struct.field("platform_version", &self.platform_version);
        debug_struct.field("platform_patch_level", &self.platform_patch_level);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Software {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Software");
        debug_struct.field("name", &self.name);
        debug_struct.field("version", &self.version);
        debug_struct.field("permissions", &self.permissions);
        debug_struct.field("description", &self.description);
        debug_struct.field("vendor_name", &self.vendor_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Asset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Asset");
        debug_struct.field("product_object_id", &self.product_object_id);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("asset_id", &self.asset_id);
        debug_struct.field("ip", &self.ip);
        debug_struct.field("mac", &self.mac);
        debug_struct.field("nat_ip", &self.nat_ip);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("hardware", &self.hardware);
        debug_struct.field("platform_software", &self.platform_software);
        debug_struct.field("software", &self.software);
        debug_struct.field("location", &self.location);
        debug_struct.field("category", &self.category);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("network_domain", &self.network_domain);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("first_discover_time", &self.first_discover_time);
        debug_struct.field("last_discover_time", &self.last_discover_time);
        debug_struct.field("system_last_update_time", &self.system_last_update_time);
        debug_struct.field("last_boot_time", &self.last_boot_time);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("deployment_status", &self.deployment_status);
        debug_struct.field("vulnerabilities", &self.vulnerabilities);
        debug_struct.field("attribute", &self.attribute);
        debug_struct.field("wmi_persistence_item", &self.wmi_persistence_item);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::User {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("User");
        debug_struct.field("product_object_id", &self.product_object_id);
        debug_struct.field("userid", &self.userid);
        debug_struct.field("user_display_name", &self.user_display_name);
        debug_struct.field("first_name", &self.first_name);
        debug_struct.field("middle_name", &self.middle_name);
        debug_struct.field("last_name", &self.last_name);
        debug_struct.field("phone_numbers", &self.phone_numbers);
        debug_struct.field("personal_address", &self.personal_address);
        debug_struct.field("attribute", &self.attribute);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("account_type", &self.account_type);
        debug_struct.field("groupid", &self.groupid);
        debug_struct.field("group_identifiers", &self.group_identifiers);
        debug_struct.field("windows_sid", &self.windows_sid);
        debug_struct.field("email_addresses", &self.email_addresses);
        debug_struct.field("employee_id", &self.employee_id);
        debug_struct.field("title", &self.title);
        debug_struct.field("company_name", &self.company_name);
        debug_struct.field("department", &self.department);
        debug_struct.field("office_address", &self.office_address);
        debug_struct.field("managers", &self.managers);
        debug_struct.field("hire_date", &self.hire_date);
        debug_struct.field("termination_date", &self.termination_date);
        debug_struct.field("time_off", &self.time_off);
        debug_struct.field("last_login_time", &self.last_login_time);
        debug_struct.field("last_password_change_time", &self.last_password_change_time);
        debug_struct.field("password_expiration_time", &self.password_expiration_time);
        debug_struct.field("account_expiration_time", &self.account_expiration_time);
        debug_struct.field("account_lockout_time", &self.account_lockout_time);
        debug_struct.field(
            "last_bad_password_attempt_time",
            &self.last_bad_password_attempt_time,
        );
        debug_struct.field(
            "user_authentication_status",
            &self.user_authentication_status,
        );
        debug_struct.field("role_name", &self.role_name);
        debug_struct.field("role_description", &self.role_description);
        debug_struct.field("user_role", &self.user_role);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::TimeOff {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TimeOff");
        debug_struct.field("interval", &self.interval);
        debug_struct.field("description", &self.description);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Permission {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Permission");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Role {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Role");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Group {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Group");
        debug_struct.field("product_object_id", &self.product_object_id);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("group_display_name", &self.group_display_name);
        debug_struct.field("attribute", &self.attribute);
        debug_struct.field("email_addresses", &self.email_addresses);
        debug_struct.field("windows_sid", &self.windows_sid);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Registry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Registry");
        debug_struct.field("registry_key", &self.registry_key);
        debug_struct.field("registry_value_name", &self.registry_value_name);
        debug_struct.field("registry_value_data", &self.registry_value_data);
        debug_struct.field("registry_value_type", &self.registry_value_type);
        debug_struct.field(
            "registry_value_binary_data",
            &self.registry_value_binary_data,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::WmiPersistenceItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WmiPersistenceItem");
        debug_struct.field("caption", &self.caption);
        debug_struct.field("name", &self.name);
        debug_struct.field("setting_id", &self.setting_id);
        debug_struct.field("derivation", &self.derivation);
        debug_struct.field("property_count", &self.property_count);
        debug_struct.field("rel_path", &self.rel_path);
        debug_struct.field("dynasty", &self.dynasty);
        debug_struct.field("wmi_super_class", &self.wmi_super_class);
        debug_struct.field("wmi_class", &self.wmi_class);
        debug_struct.field("genus", &self.genus);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Location {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Location");
        debug_struct.field("city", &self.city);
        debug_struct.field("state", &self.state);
        debug_struct.field("country_or_region", &self.country_or_region);
        debug_struct.field("name", &self.name);
        debug_struct.field("desk_name", &self.desk_name);
        debug_struct.field("floor_name", &self.floor_name);
        debug_struct.field("region_latitude", &self.region_latitude);
        debug_struct.field("region_longitude", &self.region_longitude);
        debug_struct.field("region_coordinates", &self.region_coordinates);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ScheduledTask {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ScheduledTask");
        debug_struct.field("minute", &self.minute);
        debug_struct.field("hour", &self.hour);
        debug_struct.field("month_day", &self.month_day);
        debug_struct.field("month", &self.month);
        debug_struct.field("week_day", &self.week_day);
        debug_struct.field("comment", &self.comment);
        debug_struct.field("author", &self.author);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::WindowsScheduledTask {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WindowsScheduledTask");
        debug_struct.field("author", &self.author);
        debug_struct.field("virtual_path", &self.virtual_path);
        debug_struct.field("exit_code", &self.exit_code);
        debug_struct.field("state", &self.state);
        debug_struct.field("logon_type", &self.logon_type);
        debug_struct.field("task_actions", &self.task_actions);
        debug_struct.field("task_triggers", &self.task_triggers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::windows_scheduled_task::TaskAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TaskAction");
        debug_struct.field("action_type", &self.action_type);
        debug_struct.field("exec_arguments", &self.exec_arguments);
        debug_struct.field("exec_working_directory", &self.exec_working_directory);
        debug_struct.field("com_class_id", &self.com_class_id);
        debug_struct.field("com_data", &self.com_data);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::windows_scheduled_task::TaskTrigger {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TaskTrigger");
        debug_struct.field("enabled", &self.enabled);
        debug_struct.field("duration", &self.duration);
        debug_struct.field("interval", &self.interval);
        debug_struct.field("trigger_type", &self.trigger_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ScheduledCronTask {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ScheduledCronTask");
        debug_struct.field("minute", &self.minute);
        debug_struct.field("hour", &self.hour);
        debug_struct.field("month_day", &self.month_day);
        debug_struct.field("month", &self.month);
        debug_struct.field("week_day", &self.week_day);
        debug_struct.field("comment", &self.comment);
        debug_struct.field("author", &self.author);
        debug_struct.field("event", &self.event);
        debug_struct.field("path", &self.path);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ScheduledAnacronTask {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ScheduledAnacronTask");
        debug_struct.field("period", &self.period);
        debug_struct.field("delay_minutes", &self.delay_minutes);
        debug_struct.field("job_id", &self.job_id);
        debug_struct.field("path", &self.path);
        debug_struct.field("source_line", &self.source_line);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Volume {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Volume");
        debug_struct.field("file_system", &self.file_system);
        debug_struct.field("mount_point", &self.mount_point);
        debug_struct.field("device_path", &self.device_path);
        debug_struct.field("is_mounted", &self.is_mounted);
        debug_struct.field("is_read_only", &self.is_read_only);
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Service {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Service");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("service_type", &self.service_type);
        debug_struct.field("service_types", &self.service_types);
        debug_struct.field("startup_type", &self.startup_type);
        debug_struct.field("state", &self.state);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Resource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Resource");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("resource_type", &self.resource_type);
        debug_struct.field("resource_subtype", &self.resource_subtype);
        debug_struct.field("id", &self.id);
        debug_struct.field("name", &self.name);
        debug_struct.field("parent", &self.parent);
        debug_struct.field("product_object_id", &self.product_object_id);
        debug_struct.field("attribute", &self.attribute);
        debug_struct.field("scheduled_task", &self.scheduled_task);
        debug_struct.field("scheduled_cron_task", &self.scheduled_cron_task);
        debug_struct.field("scheduled_anacron_task", &self.scheduled_anacron_task);
        debug_struct.field("windows_scheduled_task", &self.windows_scheduled_task);
        debug_struct.field("volume", &self.volume);
        debug_struct.field("service", &self.service);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Label {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Label");
        debug_struct.field("key", &self.key);
        debug_struct.field("value", &self.value);
        debug_struct.field("source", &self.source);
        debug_struct.field("rbac_enabled", &self.rbac_enabled);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Cloud {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Cloud");
        debug_struct.field("environment", &self.environment);
        debug_struct.field("vpc", &self.vpc);
        debug_struct.field("project", &self.project);
        debug_struct.field("availability_zone", &self.availability_zone);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Artifact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Artifact");
        debug_struct.field("ip", &self.ip);
        debug_struct.field("prevalence", &self.prevalence);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("last_seen_time", &self.last_seen_time);
        debug_struct.field("location", &self.location);
        debug_struct.field("network", &self.network);
        debug_struct.field("as_owner", &self.as_owner);
        debug_struct.field("asn", &self.asn);
        debug_struct.field("jarm", &self.jarm);
        debug_struct.field("last_https_certificate", &self.last_https_certificate);
        debug_struct.field(
            "last_https_certificate_date",
            &self.last_https_certificate_date,
        );
        debug_struct.field(
            "regional_internet_registry",
            &self.regional_internet_registry,
        );
        debug_struct.field("tags", &self.tags);
        debug_struct.field("whois", &self.whois);
        debug_struct.field("whois_date", &self.whois_date);
        debug_struct.field("tunnels", &self.tunnels);
        debug_struct.field("anonymous", &self.anonymous);
        debug_struct.field("artifact_client", &self.artifact_client);
        debug_struct.field("risks", &self.risks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Tunnels {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tunnels");
        debug_struct.field("provider", &self.provider);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ArtifactClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ArtifactClient");
        debug_struct.field("behaviors", &self.behaviors);
        debug_struct.field("proxies", &self.proxies);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Favicon {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Favicon");
        debug_struct.field("raw_md5", &self.raw_md5);
        debug_struct.field("dhash", &self.dhash);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DNSRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DNSRecord");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("value", &self.value);
        debug_struct.field("ttl", &self.ttl);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("retry", &self.retry);
        debug_struct.field("refresh", &self.refresh);
        debug_struct.field("minimum", &self.minimum);
        debug_struct.field("expire", &self.expire);
        debug_struct.field("serial", &self.serial);
        debug_struct.field("rname", &self.rname);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::SSLCertificate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SSLCertificate");
        debug_struct.field("cert_signature", &self.cert_signature);
        debug_struct.field("extension", &self.extension);
        debug_struct.field("cert_extensions", &self.cert_extensions);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("issuer", &self.issuer);
        debug_struct.field("ec", &self.ec);
        debug_struct.field("serial_number", &self.serial_number);
        debug_struct.field("signature_algorithm", &self.signature_algorithm);
        debug_struct.field("size", &self.size);
        debug_struct.field("subject", &self.subject);
        debug_struct.field("thumbprint", &self.thumbprint);
        debug_struct.field("thumbprint_sha256", &self.thumbprint_sha256);
        debug_struct.field("validity", &self.validity);
        debug_struct.field("version", &self.version);
        debug_struct.field("public_key", &self.public_key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::CertSignature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CertSignature");
        debug_struct.field("signature", &self.signature);
        debug_struct.field("signature_algorithm", &self.signature_algorithm);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::AuthorityKeyId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AuthorityKeyId");
        debug_struct.field("keyid", &self.keyid);
        debug_struct.field("serial_number", &self.serial_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::Extension {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Extension");
        debug_struct.field("ca", &self.ca);
        debug_struct.field("subject_key_id", &self.subject_key_id);
        debug_struct.field("authority_key_id", &self.authority_key_id);
        debug_struct.field("key_usage", &self.key_usage);
        debug_struct.field("ca_info_access", &self.ca_info_access);
        debug_struct.field("crl_distribution_points", &self.crl_distribution_points);
        debug_struct.field("extended_key_usage", &self.extended_key_usage);
        debug_struct.field("subject_alternative_name", &self.subject_alternative_name);
        debug_struct.field("certificate_policies", &self.certificate_policies);
        debug_struct.field("netscape_cert_comment", &self.netscape_cert_comment);
        debug_struct.field("cert_template_name_dc", &self.cert_template_name_dc);
        debug_struct.field("netscape_certificate", &self.netscape_certificate);
        debug_struct.field("pe_logotype", &self.pe_logotype);
        debug_struct.field("old_authority_key_id", &self.old_authority_key_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::Subject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Subject");
        debug_struct.field("country_name", &self.country_name);
        debug_struct.field("common_name", &self.common_name);
        debug_struct.field("locality", &self.locality);
        debug_struct.field("organization", &self.organization);
        debug_struct.field("organizational_unit", &self.organizational_unit);
        debug_struct.field("state_or_province_name", &self.state_or_province_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::Rsa {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Rsa");
        debug_struct.field("key_size", &self.key_size);
        debug_struct.field("modulus", &self.modulus);
        debug_struct.field("exponent", &self.exponent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::Ec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Ec");
        debug_struct.field("oid", &self.oid);
        debug_struct.field("r#pub", &self.r#pub);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::PublicKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PublicKey");
        debug_struct.field("algorithm", &self.algorithm);
        debug_struct.field("rsa", &self.rsa);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ssl_certificate::Validity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Validity");
        debug_struct.field("expiry_time", &self.expiry_time);
        debug_struct.field("issue_time", &self.issue_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::PopularityRank {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PopularityRank");
        debug_struct.field("giver", &self.giver);
        debug_struct.field("rank", &self.rank);
        debug_struct.field("ingestion_time", &self.ingestion_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Tracker {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tracker");
        debug_struct.field("tracker", &self.tracker);
        debug_struct.field("id", &self.id);
        debug_struct.field("timestamp", &self.timestamp);
        debug_struct.field("url", &self.url);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Url {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Url");
        debug_struct.field("url", &self.url);
        debug_struct.field("categories", &self.categories);
        debug_struct.field("favicon", &self.favicon);
        debug_struct.field("html_meta", &self.html_meta);
        debug_struct.field("last_final_url", &self.last_final_url);
        debug_struct.field("last_http_response_code", &self.last_http_response_code);
        debug_struct.field(
            "last_http_response_content_length",
            &self.last_http_response_content_length,
        );
        debug_struct.field(
            "last_http_response_content_sha256",
            &self.last_http_response_content_sha256,
        );
        debug_struct.field(
            "last_http_response_cookies",
            &self.last_http_response_cookies,
        );
        debug_struct.field(
            "last_http_response_headers",
            &self.last_http_response_headers,
        );
        debug_struct.field("tags", &self.tags);
        debug_struct.field("title", &self.title);
        debug_struct.field("trackers", &self.trackers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Domain {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Domain");
        debug_struct.field("name", &self.name);
        debug_struct.field("prevalence", &self.prevalence);
        debug_struct.field("first_seen_time", &self.first_seen_time);
        debug_struct.field("last_seen_time", &self.last_seen_time);
        debug_struct.field("registrar", &self.registrar);
        debug_struct.field("contact_email", &self.contact_email);
        debug_struct.field("whois_server", &self.whois_server);
        debug_struct.field("name_server", &self.name_server);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("expiration_time", &self.expiration_time);
        debug_struct.field("audit_update_time", &self.audit_update_time);
        debug_struct.field("status", &self.status);
        debug_struct.field("registrant", &self.registrant);
        debug_struct.field("admin", &self.admin);
        debug_struct.field("tech", &self.tech);
        debug_struct.field("billing", &self.billing);
        debug_struct.field("zone", &self.zone);
        debug_struct.field("whois_record_raw_text", &self.whois_record_raw_text);
        debug_struct.field("registry_data_raw_text", &self.registry_data_raw_text);
        debug_struct.field("iana_registrar_id", &self.iana_registrar_id);
        debug_struct.field("private_registration", &self.private_registration);
        debug_struct.field("categories", &self.categories);
        debug_struct.field("favicon", &self.favicon);
        debug_struct.field("jarm", &self.jarm);
        debug_struct.field("last_dns_records", &self.last_dns_records);
        debug_struct.field("last_dns_records_time", &self.last_dns_records_time);
        debug_struct.field("last_https_certificate", &self.last_https_certificate);
        debug_struct.field(
            "last_https_certificate_time",
            &self.last_https_certificate_time,
        );
        debug_struct.field("popularity_ranks", &self.popularity_ranks);
        debug_struct.field("tags", &self.tags);
        debug_struct.field("whois_time", &self.whois_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Noun {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Noun");
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("domain", &self.domain);
        debug_struct.field("artifact", &self.artifact);
        debug_struct.field("url_metadata", &self.url_metadata);
        debug_struct.field("browser", &self.browser);
        debug_struct.field("asset_id", &self.asset_id);
        debug_struct.field("user", &self.user);
        debug_struct.field("user_management_chain", &self.user_management_chain);
        debug_struct.field("group", &self.group);
        debug_struct.field("process", &self.process);
        debug_struct.field("process_ancestors", &self.process_ancestors);
        debug_struct.field("asset", &self.asset);
        debug_struct.field("ip", &self.ip);
        debug_struct.field("nat_ip", &self.nat_ip);
        debug_struct.field("port", &self.port);
        debug_struct.field("nat_port", &self.nat_port);
        debug_struct.field("mac", &self.mac);
        debug_struct.field("administrative_domain", &self.administrative_domain);
        debug_struct.field("namespace", &self.namespace);
        debug_struct.field("url", &self.url);
        debug_struct.field("file", &self.file);
        debug_struct.field("email", &self.email);
        debug_struct.field("registry", &self.registry);
        debug_struct.field("application", &self.application);
        debug_struct.field("platform", &self.platform);
        debug_struct.field("platform_version", &self.platform_version);
        debug_struct.field("platform_patch_level", &self.platform_patch_level);
        debug_struct.field("cloud", &self.cloud);
        debug_struct.field("location", &self.location);
        debug_struct.field("ip_location", &self.ip_location);
        debug_struct.field("ip_geo_artifact", &self.ip_geo_artifact);
        debug_struct.field("resource", &self.resource);
        debug_struct.field("resource_ancestors", &self.resource_ancestors);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("object_reference", &self.object_reference);
        debug_struct.field("investigation", &self.investigation);
        debug_struct.field("network", &self.network);
        debug_struct.field("security_result", &self.security_result);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Investigation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Investigation");
        debug_struct.field("verdict", &self.verdict);
        debug_struct.field("reputation", &self.reputation);
        debug_struct.field("severity_score", &self.severity_score);
        debug_struct.field("status", &self.status);
        debug_struct.field("comments", &self.comments);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("root_cause", &self.root_cause);
        debug_struct.field("reason", &self.reason);
        debug_struct.field("risk_score", &self.risk_score);
        debug_struct.field("id", &self.id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Tags {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tags");
        debug_struct.field("tenant_id", &self.tenant_id);
        debug_struct.field("data_tap_config_name", &self.data_tap_config_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::AttackDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AttackDetails");
        debug_struct.field("version", &self.version);
        debug_struct.field("tactics", &self.tactics);
        debug_struct.field("techniques", &self.techniques);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::attack_details::Tactic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Tactic");
        debug_struct.field("id", &self.id);
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::attack_details::Technique {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Technique");
        debug_struct.field("id", &self.id);
        debug_struct.field("name", &self.name);
        debug_struct.field("subtechnique_id", &self.subtechnique_id);
        debug_struct.field("subtechnique_name", &self.subtechnique_name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BoolSequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoolSequence");
        debug_struct.field("bool_vals", &self.bool_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::BytesSequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BytesSequence");
        debug_struct.field("bytes_vals", &self.bytes_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DoubleSequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DoubleSequence");
        debug_struct.field("double_vals", &self.double_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Int64Sequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Int64Sequence");
        debug_struct.field("int64_vals", &self.int64_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Uint64Sequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Uint64Sequence");
        debug_struct.field("uint64_vals", &self.uint64_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::StringSequence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StringSequence");
        debug_struct.field("string_vals", &self.string_vals);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::GroupedFields {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GroupedFields");
        debug_struct.field("ip", &self.ip);
        debug_struct.field("domain", &self.domain);
        debug_struct.field("hostname", &self.hostname);
        debug_struct.field("user", &self.user);
        debug_struct.field("email", &self.email);
        debug_struct.field("file_path", &self.file_path);
        debug_struct.field("hash", &self.hash);
        debug_struct.field("process_id", &self.process_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}