google-cloud-dns-v1 2.0.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::Change {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Change");
        debug_struct.field("additions", &self.additions);
        debug_struct.field("deletions", &self.deletions);
        debug_struct.field("id", &self.id);
        debug_struct.field("is_serving", &self.is_serving);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("start_time", &self.start_time);
        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::ChangesListResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ChangesListResponse");
        debug_struct.field("changes", &self.changes);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

impl std::fmt::Debug for super::DnsKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DnsKey");
        debug_struct.field("algorithm", &self.algorithm);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("description", &self.description);
        debug_struct.field("digests", &self.digests);
        debug_struct.field("id", &self.id);
        debug_struct.field("is_active", &self.is_active);
        debug_struct.field("key_length", &self.key_length);
        debug_struct.field("key_tag", &self.key_tag);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("public_key", &self.public_key);
        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::DnsKeyDigest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DnsKeyDigest");
        debug_struct.field("digest", &self.digest);
        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::DnsKeySpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DnsKeySpec");
        debug_struct.field("algorithm", &self.algorithm);
        debug_struct.field("key_length", &self.key_length);
        debug_struct.field("key_type", &self.key_type);
        debug_struct.field("kind", &self.kind);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl std::fmt::Debug for super::ManagedZone {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ManagedZone");
        debug_struct.field("cloud_logging_config", &self.cloud_logging_config);
        debug_struct.field("creation_time", &self.creation_time);
        debug_struct.field("description", &self.description);
        debug_struct.field("dns_name", &self.dns_name);
        debug_struct.field("dnssec_config", &self.dnssec_config);
        debug_struct.field("forwarding_config", &self.forwarding_config);
        debug_struct.field("id", &self.id);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("labels", &self.labels);
        debug_struct.field("name", &self.name);
        debug_struct.field("name_server_set", &self.name_server_set);
        debug_struct.field("name_servers", &self.name_servers);
        debug_struct.field("peering_config", &self.peering_config);
        debug_struct.field("private_visibility_config", &self.private_visibility_config);
        debug_struct.field("reverse_lookup_config", &self.reverse_lookup_config);
        debug_struct.field("service_directory_config", &self.service_directory_config);
        debug_struct.field("visibility", &self.visibility);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

impl std::fmt::Debug for super::ManagedZoneDnsSecConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ManagedZoneDnsSecConfig");
        debug_struct.field("default_key_specs", &self.default_key_specs);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("non_existence", &self.non_existence);
        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::ManagedZoneForwardingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ManagedZoneForwardingConfig");
        debug_struct.field("kind", &self.kind);
        debug_struct.field("target_name_servers", &self.target_name_servers);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl std::fmt::Debug for super::Policy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Policy");
        debug_struct.field(
            "alternative_name_server_config",
            &self.alternative_name_server_config,
        );
        debug_struct.field("description", &self.description);
        debug_struct.field("dns_64_config", &self.dns_64_config);
        debug_struct.field("enable_inbound_forwarding", &self.enable_inbound_forwarding);
        debug_struct.field("enable_logging", &self.enable_logging);
        debug_struct.field("id", &self.id);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("name", &self.name);
        debug_struct.field("networks", &self.networks);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

impl std::fmt::Debug for super::Quota {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Quota");
        debug_struct.field("dns_keys_per_managed_zone", &self.dns_keys_per_managed_zone);
        debug_struct.field(
            "gke_clusters_per_managed_zone",
            &self.gke_clusters_per_managed_zone,
        );
        debug_struct.field("gke_clusters_per_policy", &self.gke_clusters_per_policy);
        debug_struct.field(
            "gke_clusters_per_response_policy",
            &self.gke_clusters_per_response_policy,
        );
        debug_struct.field(
            "internet_health_checks_per_managed_zone",
            &self.internet_health_checks_per_managed_zone,
        );
        debug_struct.field("items_per_routing_policy", &self.items_per_routing_policy);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("managed_zones", &self.managed_zones);
        debug_struct.field(
            "managed_zones_per_gke_cluster",
            &self.managed_zones_per_gke_cluster,
        );
        debug_struct.field("managed_zones_per_network", &self.managed_zones_per_network);
        debug_struct.field(
            "nameservers_per_delegation",
            &self.nameservers_per_delegation,
        );
        debug_struct.field("networks_per_managed_zone", &self.networks_per_managed_zone);
        debug_struct.field("networks_per_policy", &self.networks_per_policy);
        debug_struct.field(
            "networks_per_response_policy",
            &self.networks_per_response_policy,
        );
        debug_struct.field(
            "peering_zones_per_target_network",
            &self.peering_zones_per_target_network,
        );
        debug_struct.field("policies", &self.policies);
        debug_struct.field(
            "resource_records_per_rrset",
            &self.resource_records_per_rrset,
        );
        debug_struct.field("response_policies", &self.response_policies);
        debug_struct.field(
            "response_policy_rules_per_response_policy",
            &self.response_policy_rules_per_response_policy,
        );
        debug_struct.field(
            "rrset_additions_per_change",
            &self.rrset_additions_per_change,
        );
        debug_struct.field(
            "rrset_deletions_per_change",
            &self.rrset_deletions_per_change,
        );
        debug_struct.field("rrsets_per_managed_zone", &self.rrsets_per_managed_zone);
        debug_struct.field(
            "target_name_servers_per_managed_zone",
            &self.target_name_servers_per_managed_zone,
        );
        debug_struct.field(
            "target_name_servers_per_policy",
            &self.target_name_servers_per_policy,
        );
        debug_struct.field(
            "total_rrdata_size_per_change",
            &self.total_rrdata_size_per_change,
        );
        debug_struct.field("whitelisted_key_specs", &self.whitelisted_key_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

impl std::fmt::Debug for super::RRSetRoutingPolicyLoadBalancerTarget {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RRSetRoutingPolicyLoadBalancerTarget");
        debug_struct.field("ip_address", &self.ip_address);
        debug_struct.field("ip_protocol", &self.ip_protocol);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("load_balancer_type", &self.load_balancer_type);
        debug_struct.field("network_url", &self.network_url);
        debug_struct.field("port", &self.port);
        debug_struct.field("project", &self.project);
        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::RRSetRoutingPolicyPrimaryBackupPolicy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RRSetRoutingPolicyPrimaryBackupPolicy");
        debug_struct.field("backup_geo_targets", &self.backup_geo_targets);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("primary_targets", &self.primary_targets);
        debug_struct.field("trickle_traffic", &self.trickle_traffic);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

impl std::fmt::Debug for super::ResourceRecordSet {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceRecordSet");
        debug_struct.field("kind", &self.kind);
        debug_struct.field("name", &self.name);
        debug_struct.field("routing_policy", &self.routing_policy);
        debug_struct.field("rrdatas", &self.rrdatas);
        debug_struct.field("signature_rrdatas", &self.signature_rrdatas);
        debug_struct.field("ttl", &self.ttl);
        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::ResourceRecordSetsDeleteResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResourceRecordSetsDeleteResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl std::fmt::Debug for super::changes::ListRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRequest");
        debug_struct.field("managed_zone", &self.managed_zone);
        debug_struct.field("max_results", &self.max_results);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("project", &self.project);
        debug_struct.field("sort_by", &self.sort_by);
        debug_struct.field("sort_order", &self.sort_order);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl std::fmt::Debug for super::resource_record_sets::DeleteRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteRequest");
        debug_struct.field("client_operation_id", &self.client_operation_id);
        debug_struct.field("managed_zone", &self.managed_zone);
        debug_struct.field("name", &self.name);
        debug_struct.field("project", &self.project);
        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::resource_record_sets::GetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetRequest");
        debug_struct.field("client_operation_id", &self.client_operation_id);
        debug_struct.field("managed_zone", &self.managed_zone);
        debug_struct.field("name", &self.name);
        debug_struct.field("project", &self.project);
        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::resource_record_sets::ListRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListRequest");
        debug_struct.field("filter", &self.filter);
        debug_struct.field("managed_zone", &self.managed_zone);
        debug_struct.field("max_results", &self.max_results);
        debug_struct.field("name", &self.name);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("project", &self.project);
        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::resource_record_sets::PatchRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("PatchRequest");
        debug_struct.field("client_operation_id", &self.client_operation_id);
        debug_struct.field("managed_zone", &self.managed_zone);
        debug_struct.field("name", &self.name);
        debug_struct.field("project", &self.project);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("body", &self.body);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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