google-cloud-networkmanagement-v1 1.9.0

// Copyright 2025 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::ConnectivityTest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConnectivityTest");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("source", &self.source);
        debug_struct.field("destination", &self.destination);
        debug_struct.field("protocol", &self.protocol);
        debug_struct.field("related_projects", &self.related_projects);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("reachability_details", &self.reachability_details);
        debug_struct.field("probing_details", &self.probing_details);
        debug_struct.field("round_trip", &self.round_trip);
        debug_struct.field(
            "return_reachability_details",
            &self.return_reachability_details,
        );
        debug_struct.field("bypass_firewall_checks", &self.bypass_firewall_checks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::Endpoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Endpoint");
        debug_struct.field("ip_address", &self.ip_address);
        debug_struct.field("port", &self.port);
        debug_struct.field("instance", &self.instance);
        debug_struct.field("forwarding_rule", &self.forwarding_rule);
        debug_struct.field("forwarding_rule_target", &self.forwarding_rule_target);
        debug_struct.field("load_balancer_id", &self.load_balancer_id);
        debug_struct.field("load_balancer_type", &self.load_balancer_type);
        debug_struct.field("gke_master_cluster", &self.gke_master_cluster);
        debug_struct.field("fqdn", &self.fqdn);
        debug_struct.field("cloud_sql_instance", &self.cloud_sql_instance);
        debug_struct.field("redis_instance", &self.redis_instance);
        debug_struct.field("redis_cluster", &self.redis_cluster);
        debug_struct.field("gke_pod", &self.gke_pod);
        debug_struct.field("cloud_function", &self.cloud_function);
        debug_struct.field("app_engine_version", &self.app_engine_version);
        debug_struct.field("cloud_run_revision", &self.cloud_run_revision);
        debug_struct.field("network", &self.network);
        debug_struct.field("network_type", &self.network_type);
        debug_struct.field("project_id", &self.project_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

impl std::fmt::Debug for super::ProbingDetails {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProbingDetails");
        debug_struct.field("result", &self.result);
        debug_struct.field("verify_time", &self.verify_time);
        debug_struct.field("error", &self.error);
        debug_struct.field("abort_cause", &self.abort_cause);
        debug_struct.field("sent_probe_count", &self.sent_probe_count);
        debug_struct.field("successful_probe_count", &self.successful_probe_count);
        debug_struct.field("endpoint_info", &self.endpoint_info);
        debug_struct.field("probing_latency", &self.probing_latency);
        debug_struct.field(
            "destination_egress_location",
            &self.destination_egress_location,
        );
        debug_struct.field("edge_responses", &self.edge_responses);
        debug_struct.field("probed_all_devices", &self.probed_all_devices);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::probing_details::SingleEdgeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SingleEdgeResponse");
        debug_struct.field("result", &self.result);
        debug_struct.field("sent_probe_count", &self.sent_probe_count);
        debug_struct.field("successful_probe_count", &self.successful_probe_count);
        debug_struct.field("probing_latency", &self.probing_latency);
        debug_struct.field(
            "destination_egress_location",
            &self.destination_egress_location,
        );
        debug_struct.field("destination_router", &self.destination_router);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

impl std::fmt::Debug for super::GetConnectivityTestRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConnectivityTestRequest");
        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::CreateConnectivityTestRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConnectivityTestRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("test_id", &self.test_id);
        debug_struct.field("resource", &self.resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::DeleteConnectivityTestRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConnectivityTestRequest");
        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::RerunConnectivityTestRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RerunConnectivityTestRequest");
        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::OperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OperationMetadata");
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("target", &self.target);
        debug_struct.field("verb", &self.verb);
        debug_struct.field("status_detail", &self.status_detail);
        debug_struct.field("cancel_requested", &self.cancel_requested);
        debug_struct.field("api_version", &self.api_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

impl std::fmt::Debug for super::InstanceInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InstanceInfo");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("interface", &self.interface);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("internal_ip", &self.internal_ip);
        debug_struct.field("external_ip", &self.external_ip);
        debug_struct.field("network_tags", &self.network_tags);
        debug_struct.field("service_account", &self.service_account);
        debug_struct.field(
            "psc_network_attachment_uri",
            &self.psc_network_attachment_uri,
        );
        debug_struct.field("running", &self.running);
        debug_struct.field("status", &self.status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::FirewallInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FirewallInfo");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("direction", &self.direction);
        debug_struct.field("action", &self.action);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("target_tags", &self.target_tags);
        debug_struct.field("target_service_accounts", &self.target_service_accounts);
        debug_struct.field("policy", &self.policy);
        debug_struct.field("policy_uri", &self.policy_uri);
        debug_struct.field("firewall_rule_type", &self.firewall_rule_type);
        debug_struct.field("policy_priority", &self.policy_priority);
        debug_struct.field("target_type", &self.target_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::RouteInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RouteInfo");
        debug_struct.field("route_type", &self.route_type);
        debug_struct.field("next_hop_type", &self.next_hop_type);
        debug_struct.field("route_scope", &self.route_scope);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("region", &self.region);
        debug_struct.field("dest_ip_range", &self.dest_ip_range);
        debug_struct.field("next_hop", &self.next_hop);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("instance_tags", &self.instance_tags);
        debug_struct.field("src_ip_range", &self.src_ip_range);
        debug_struct.field("dest_port_ranges", &self.dest_port_ranges);
        debug_struct.field("src_port_ranges", &self.src_port_ranges);
        debug_struct.field("protocols", &self.protocols);
        debug_struct.field("ncc_hub_uri", &self.ncc_hub_uri);
        debug_struct.field("ncc_spoke_uri", &self.ncc_spoke_uri);
        debug_struct.field(
            "advertised_route_source_router_uri",
            &self.advertised_route_source_router_uri,
        );
        debug_struct.field(
            "advertised_route_next_hop_uri",
            &self.advertised_route_next_hop_uri,
        );
        debug_struct.field("next_hop_uri", &self.next_hop_uri);
        debug_struct.field("next_hop_network_uri", &self.next_hop_network_uri);
        debug_struct.field("originating_route_uri", &self.originating_route_uri);
        debug_struct.field(
            "originating_route_display_name",
            &self.originating_route_display_name,
        );
        debug_struct.field("ncc_hub_route_uri", &self.ncc_hub_route_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::ForwardingRuleInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ForwardingRuleInfo");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("matched_protocol", &self.matched_protocol);
        debug_struct.field("matched_port_range", &self.matched_port_range);
        debug_struct.field("vip", &self.vip);
        debug_struct.field("target", &self.target);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("region", &self.region);
        debug_struct.field("load_balancer_name", &self.load_balancer_name);
        debug_struct.field(
            "psc_service_attachment_uri",
            &self.psc_service_attachment_uri,
        );
        debug_struct.field("psc_google_api_target", &self.psc_google_api_target);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

impl std::fmt::Debug for super::VpnTunnelInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VpnTunnelInfo");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("source_gateway", &self.source_gateway);
        debug_struct.field("remote_gateway", &self.remote_gateway);
        debug_struct.field("remote_gateway_ip", &self.remote_gateway_ip);
        debug_struct.field("source_gateway_ip", &self.source_gateway_ip);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("region", &self.region);
        debug_struct.field("routing_type", &self.routing_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::EndpointInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EndpointInfo");
        debug_struct.field("source_ip", &self.source_ip);
        debug_struct.field("destination_ip", &self.destination_ip);
        debug_struct.field("protocol", &self.protocol);
        debug_struct.field("source_port", &self.source_port);
        debug_struct.field("destination_port", &self.destination_port);
        debug_struct.field("source_network_uri", &self.source_network_uri);
        debug_struct.field("destination_network_uri", &self.destination_network_uri);
        debug_struct.field("source_agent_uri", &self.source_agent_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

impl std::fmt::Debug for super::DropInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DropInfo");
        debug_struct.field("cause", &self.cause);
        debug_struct.field("resource_uri", &self.resource_uri);
        debug_struct.field("source_ip", &self.source_ip);
        debug_struct.field("destination_ip", &self.destination_ip);
        debug_struct.field("region", &self.region);
        debug_struct.field("source_geolocation_code", &self.source_geolocation_code);
        debug_struct.field(
            "destination_geolocation_code",
            &self.destination_geolocation_code,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl std::fmt::Debug for super::NatInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NatInfo");
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("protocol", &self.protocol);
        debug_struct.field("network_uri", &self.network_uri);
        debug_struct.field("old_source_ip", &self.old_source_ip);
        debug_struct.field("new_source_ip", &self.new_source_ip);
        debug_struct.field("old_destination_ip", &self.old_destination_ip);
        debug_struct.field("new_destination_ip", &self.new_destination_ip);
        debug_struct.field("old_source_port", &self.old_source_port);
        debug_struct.field("new_source_port", &self.new_source_port);
        debug_struct.field("old_destination_port", &self.old_destination_port);
        debug_struct.field("new_destination_port", &self.new_destination_port);
        debug_struct.field("router_uri", &self.router_uri);
        debug_struct.field("nat_gateway_name", &self.nat_gateway_name);
        debug_struct.field("cloud_nat_gateway_type", &self.cloud_nat_gateway_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::ProxyConnectionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ProxyConnectionInfo");
        debug_struct.field("protocol", &self.protocol);
        debug_struct.field("old_source_ip", &self.old_source_ip);
        debug_struct.field("new_source_ip", &self.new_source_ip);
        debug_struct.field("old_destination_ip", &self.old_destination_ip);
        debug_struct.field("new_destination_ip", &self.new_destination_ip);
        debug_struct.field("old_source_port", &self.old_source_port);
        debug_struct.field("new_source_port", &self.new_source_port);
        debug_struct.field("old_destination_port", &self.old_destination_port);
        debug_struct.field("new_destination_port", &self.new_destination_port);
        debug_struct.field("subnet_uri", &self.subnet_uri);
        debug_struct.field("network_uri", &self.network_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::LoadBalancerBackendInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LoadBalancerBackendInfo");
        debug_struct.field("name", &self.name);
        debug_struct.field("instance_uri", &self.instance_uri);
        debug_struct.field("backend_service_uri", &self.backend_service_uri);
        debug_struct.field("instance_group_uri", &self.instance_group_uri);
        debug_struct.field(
            "network_endpoint_group_uri",
            &self.network_endpoint_group_uri,
        );
        debug_struct.field("backend_bucket_uri", &self.backend_bucket_uri);
        debug_struct.field(
            "psc_service_attachment_uri",
            &self.psc_service_attachment_uri,
        );
        debug_struct.field("psc_google_api_target", &self.psc_google_api_target);
        debug_struct.field("health_check_uri", &self.health_check_uri);
        debug_struct.field(
            "health_check_firewalls_config_state",
            &self.health_check_firewalls_config_state,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

impl std::fmt::Debug for super::GetVpcFlowLogsConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetVpcFlowLogsConfigRequest");
        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::CreateVpcFlowLogsConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateVpcFlowLogsConfigRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("vpc_flow_logs_config_id", &self.vpc_flow_logs_config_id);
        debug_struct.field("vpc_flow_logs_config", &self.vpc_flow_logs_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::DeleteVpcFlowLogsConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteVpcFlowLogsConfigRequest");
        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::QueryOrgVpcFlowLogsConfigsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryOrgVpcFlowLogsConfigsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

impl std::fmt::Debug for super::VpcFlowLogsConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VpcFlowLogsConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("state", &self.state);
        debug_struct.field("aggregation_interval", &self.aggregation_interval);
        debug_struct.field("flow_sampling", &self.flow_sampling);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("metadata_fields", &self.metadata_fields);
        debug_struct.field("filter_expr", &self.filter_expr);
        debug_struct.field("cross_project_metadata", &self.cross_project_metadata);
        debug_struct.field("target_resource_state", &self.target_resource_state);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("target_resource", &self.target_resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::EffectiveVpcFlowLogsConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EffectiveVpcFlowLogsConfig");
        debug_struct.field("name", &self.name);
        debug_struct.field("state", &self.state);
        debug_struct.field("aggregation_interval", &self.aggregation_interval);
        debug_struct.field("flow_sampling", &self.flow_sampling);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("metadata_fields", &self.metadata_fields);
        debug_struct.field("filter_expr", &self.filter_expr);
        debug_struct.field("cross_project_metadata", &self.cross_project_metadata);
        debug_struct.field("scope", &self.scope);
        debug_struct.field("target_resource", &self.target_resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}