google_cloud_container_v1/

model.rs

// 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(rustdoc::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_rpc;
extern crate google_cloud_type;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// Parameters that can be configured on Linux nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LinuxNodeConfig {
    /// The Linux kernel parameters to be applied to the nodes and all pods running
    /// on the nodes.
    ///
    /// The following parameters are supported.
    ///
    /// net.core.busy_poll
    /// net.core.busy_read
    /// net.core.netdev_max_backlog
    /// net.core.rmem_max
    /// net.core.rmem_default
    /// net.core.wmem_default
    /// net.core.wmem_max
    /// net.core.optmem_max
    /// net.core.somaxconn
    /// net.ipv4.neigh.default.gc_thresh1
    /// net.ipv4.neigh.default.gc_thresh2
    /// net.ipv4.neigh.default.gc_thresh3
    /// net.ipv4.tcp_rmem
    /// net.ipv4.tcp_wmem
    /// net.ipv4.tcp_tw_reuse
    /// net.ipv4.tcp_mtu_probing
    /// net.ipv4.tcp_max_orphans
    /// net.ipv4.tcp_max_tw_buckets
    /// net.ipv4.tcp_syn_retries
    /// net.ipv4.tcp_ecn
    /// net.ipv4.tcp_congestion_control
    /// net.netfilter.nf_conntrack_max
    /// net.netfilter.nf_conntrack_buckets
    /// net.netfilter.nf_conntrack_tcp_timeout_close_wait
    /// net.netfilter.nf_conntrack_tcp_timeout_time_wait
    /// net.netfilter.nf_conntrack_tcp_timeout_established
    /// net.netfilter.nf_conntrack_acct
    /// kernel.keys.maxkeys
    /// kernel.keys.maxbytes
    /// kernel.shmmni
    /// kernel.shmmax
    /// kernel.shmall
    /// kernel.perf_event_paranoid
    /// kernel.sched_rt_runtime_us
    /// kernel.softlockup_panic
    /// kernel.yama.ptrace_scope
    /// kernel.kptr_restrict
    /// kernel.dmesg_restrict
    /// kernel.sysrq
    /// fs.aio-max-nr
    /// fs.file-max
    /// fs.inotify.max_user_instances
    /// fs.inotify.max_user_watches
    /// fs.nr_open
    /// vm.dirty_background_ratio
    /// vm.dirty_background_bytes
    /// vm.dirty_expire_centisecs
    /// vm.dirty_ratio
    /// vm.dirty_bytes
    /// vm.dirty_writeback_centisecs
    /// vm.max_map_count
    /// vm.overcommit_memory
    /// vm.overcommit_ratio
    /// vm.vfs_cache_pressure
    /// vm.swappiness
    /// vm.watermark_scale_factor
    /// vm.min_free_kbytes
    pub sysctls: std::collections::HashMap<std::string::String, std::string::String>,

    /// cgroup_mode specifies the cgroup mode to be used on the node.
    pub cgroup_mode: crate::model::linux_node_config::CgroupMode,

    /// Optional. Amounts for 2M and 1G hugepages
    pub hugepages: std::option::Option<crate::model::linux_node_config::HugepagesConfig>,

    /// Optional. Transparent hugepage support for anonymous memory can be entirely
    /// disabled (mostly for debugging purposes) or only enabled inside
    /// MADV_HUGEPAGE regions (to avoid the risk of consuming more memory
    /// resources) or enabled system wide.
    ///
    /// See <https://docs.kernel.org/admin-guide/mm/transhuge.html>
    /// for more details.
    pub transparent_hugepage_enabled: crate::model::linux_node_config::TransparentHugepageEnabled,

    /// Optional. Defines the transparent hugepage defrag configuration on the
    /// node. VM hugepage allocation can be managed by either limiting
    /// defragmentation for delayed allocation or skipping it entirely for
    /// immediate allocation only.
    ///
    /// See <https://docs.kernel.org/admin-guide/mm/transhuge.html>
    /// for more details.
    pub transparent_hugepage_defrag: crate::model::linux_node_config::TransparentHugepageDefrag,

    /// Optional. Allow users to run arbitrary bash script or container on the
    /// node.
    pub custom_node_init: std::option::Option<crate::model::linux_node_config::CustomNodeInit>,

    /// Optional. Enables and configures swap space on nodes.
    /// If omitted, swap is disabled.
    pub swap_config: std::option::Option<crate::model::linux_node_config::SwapConfig>,

    /// Optional. Configuration for kernel module loading on nodes.
    /// When enabled, the node pool will be provisioned with a Container-Optimized
    /// OS image that enforces kernel module signature verification.
    pub node_kernel_module_loading:
        std::option::Option<crate::model::linux_node_config::NodeKernelModuleLoading>,

    /// Optional. The accurate time configuration for the node pool.
    pub accurate_time_config:
        std::option::Option<crate::model::linux_node_config::AccurateTimeConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LinuxNodeConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [sysctls][crate::model::LinuxNodeConfig::sysctls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = LinuxNodeConfig::new().set_sysctls([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_sysctls<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.sysctls = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [cgroup_mode][crate::model::LinuxNodeConfig::cgroup_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::CgroupMode;
    /// let x0 = LinuxNodeConfig::new().set_cgroup_mode(CgroupMode::V1);
    /// let x1 = LinuxNodeConfig::new().set_cgroup_mode(CgroupMode::V2);
    /// ```
    pub fn set_cgroup_mode<T: std::convert::Into<crate::model::linux_node_config::CgroupMode>>(
        mut self,
        v: T,
    ) -> Self {
        self.cgroup_mode = v.into();
        self
    }

    /// Sets the value of [hugepages][crate::model::LinuxNodeConfig::hugepages].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
    /// let x = LinuxNodeConfig::new().set_hugepages(HugepagesConfig::default()/* use setters */);
    /// ```
    pub fn set_hugepages<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::HugepagesConfig>,
    {
        self.hugepages = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [hugepages][crate::model::LinuxNodeConfig::hugepages].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
    /// let x = LinuxNodeConfig::new().set_or_clear_hugepages(Some(HugepagesConfig::default()/* use setters */));
    /// let x = LinuxNodeConfig::new().set_or_clear_hugepages(None::<HugepagesConfig>);
    /// ```
    pub fn set_or_clear_hugepages<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::HugepagesConfig>,
    {
        self.hugepages = v.map(|x| x.into());
        self
    }

    /// Sets the value of [transparent_hugepage_enabled][crate::model::LinuxNodeConfig::transparent_hugepage_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::TransparentHugepageEnabled;
    /// let x0 = LinuxNodeConfig::new().set_transparent_hugepage_enabled(TransparentHugepageEnabled::Always);
    /// let x1 = LinuxNodeConfig::new().set_transparent_hugepage_enabled(TransparentHugepageEnabled::Madvise);
    /// let x2 = LinuxNodeConfig::new().set_transparent_hugepage_enabled(TransparentHugepageEnabled::Never);
    /// ```
    pub fn set_transparent_hugepage_enabled<
        T: std::convert::Into<crate::model::linux_node_config::TransparentHugepageEnabled>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transparent_hugepage_enabled = v.into();
        self
    }

    /// Sets the value of [transparent_hugepage_defrag][crate::model::LinuxNodeConfig::transparent_hugepage_defrag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::TransparentHugepageDefrag;
    /// let x0 = LinuxNodeConfig::new().set_transparent_hugepage_defrag(TransparentHugepageDefrag::Always);
    /// let x1 = LinuxNodeConfig::new().set_transparent_hugepage_defrag(TransparentHugepageDefrag::Defer);
    /// let x2 = LinuxNodeConfig::new().set_transparent_hugepage_defrag(TransparentHugepageDefrag::DeferWithMadvise);
    /// ```
    pub fn set_transparent_hugepage_defrag<
        T: std::convert::Into<crate::model::linux_node_config::TransparentHugepageDefrag>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.transparent_hugepage_defrag = v.into();
        self
    }

    /// Sets the value of [custom_node_init][crate::model::LinuxNodeConfig::custom_node_init].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::CustomNodeInit;
    /// let x = LinuxNodeConfig::new().set_custom_node_init(CustomNodeInit::default()/* use setters */);
    /// ```
    pub fn set_custom_node_init<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::CustomNodeInit>,
    {
        self.custom_node_init = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [custom_node_init][crate::model::LinuxNodeConfig::custom_node_init].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::CustomNodeInit;
    /// let x = LinuxNodeConfig::new().set_or_clear_custom_node_init(Some(CustomNodeInit::default()/* use setters */));
    /// let x = LinuxNodeConfig::new().set_or_clear_custom_node_init(None::<CustomNodeInit>);
    /// ```
    pub fn set_or_clear_custom_node_init<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::CustomNodeInit>,
    {
        self.custom_node_init = v.map(|x| x.into());
        self
    }

    /// Sets the value of [swap_config][crate::model::LinuxNodeConfig::swap_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::SwapConfig;
    /// let x = LinuxNodeConfig::new().set_swap_config(SwapConfig::default()/* use setters */);
    /// ```
    pub fn set_swap_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::SwapConfig>,
    {
        self.swap_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [swap_config][crate::model::LinuxNodeConfig::swap_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::SwapConfig;
    /// let x = LinuxNodeConfig::new().set_or_clear_swap_config(Some(SwapConfig::default()/* use setters */));
    /// let x = LinuxNodeConfig::new().set_or_clear_swap_config(None::<SwapConfig>);
    /// ```
    pub fn set_or_clear_swap_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::SwapConfig>,
    {
        self.swap_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_kernel_module_loading][crate::model::LinuxNodeConfig::node_kernel_module_loading].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::NodeKernelModuleLoading;
    /// let x = LinuxNodeConfig::new().set_node_kernel_module_loading(NodeKernelModuleLoading::default()/* use setters */);
    /// ```
    pub fn set_node_kernel_module_loading<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::NodeKernelModuleLoading>,
    {
        self.node_kernel_module_loading = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_kernel_module_loading][crate::model::LinuxNodeConfig::node_kernel_module_loading].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::NodeKernelModuleLoading;
    /// let x = LinuxNodeConfig::new().set_or_clear_node_kernel_module_loading(Some(NodeKernelModuleLoading::default()/* use setters */));
    /// let x = LinuxNodeConfig::new().set_or_clear_node_kernel_module_loading(None::<NodeKernelModuleLoading>);
    /// ```
    pub fn set_or_clear_node_kernel_module_loading<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::NodeKernelModuleLoading>,
    {
        self.node_kernel_module_loading = v.map(|x| x.into());
        self
    }

    /// Sets the value of [accurate_time_config][crate::model::LinuxNodeConfig::accurate_time_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::AccurateTimeConfig;
    /// let x = LinuxNodeConfig::new().set_accurate_time_config(AccurateTimeConfig::default()/* use setters */);
    /// ```
    pub fn set_accurate_time_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::AccurateTimeConfig>,
    {
        self.accurate_time_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [accurate_time_config][crate::model::LinuxNodeConfig::accurate_time_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LinuxNodeConfig;
    /// use google_cloud_container_v1::model::linux_node_config::AccurateTimeConfig;
    /// let x = LinuxNodeConfig::new().set_or_clear_accurate_time_config(Some(AccurateTimeConfig::default()/* use setters */));
    /// let x = LinuxNodeConfig::new().set_or_clear_accurate_time_config(None::<AccurateTimeConfig>);
    /// ```
    pub fn set_or_clear_accurate_time_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::linux_node_config::AccurateTimeConfig>,
    {
        self.accurate_time_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for LinuxNodeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LinuxNodeConfig"
    }
}

/// Defines additional types related to [LinuxNodeConfig].
pub mod linux_node_config {
    #[allow(unused_imports)]
    use super::*;

    /// Hugepages amount in both 2m and 1g size
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct HugepagesConfig {
        /// Optional. Amount of 2M hugepages
        pub hugepage_size2m: std::option::Option<i32>,

        /// Optional. Amount of 1G hugepages
        pub hugepage_size1g: std::option::Option<i32>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl HugepagesConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [hugepage_size2m][crate::model::linux_node_config::HugepagesConfig::hugepage_size2m].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
        /// let x = HugepagesConfig::new().set_hugepage_size2m(42);
        /// ```
        pub fn set_hugepage_size2m<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.hugepage_size2m = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [hugepage_size2m][crate::model::linux_node_config::HugepagesConfig::hugepage_size2m].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
        /// let x = HugepagesConfig::new().set_or_clear_hugepage_size2m(Some(42));
        /// let x = HugepagesConfig::new().set_or_clear_hugepage_size2m(None::<i32>);
        /// ```
        pub fn set_or_clear_hugepage_size2m<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.hugepage_size2m = v.map(|x| x.into());
            self
        }

        /// Sets the value of [hugepage_size1g][crate::model::linux_node_config::HugepagesConfig::hugepage_size1g].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
        /// let x = HugepagesConfig::new().set_hugepage_size1g(42);
        /// ```
        pub fn set_hugepage_size1g<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.hugepage_size1g = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [hugepage_size1g][crate::model::linux_node_config::HugepagesConfig::hugepage_size1g].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::HugepagesConfig;
        /// let x = HugepagesConfig::new().set_or_clear_hugepage_size1g(Some(42));
        /// let x = HugepagesConfig::new().set_or_clear_hugepage_size1g(None::<i32>);
        /// ```
        pub fn set_or_clear_hugepage_size1g<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<i32>,
        {
            self.hugepage_size1g = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for HugepagesConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.LinuxNodeConfig.HugepagesConfig"
        }
    }

    /// Support for running custom init code while bootstrapping nodes.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CustomNodeInit {
        /// Optional. The init script to be executed on the node.
        pub init_script:
            std::option::Option<crate::model::linux_node_config::custom_node_init::InitScript>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl CustomNodeInit {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [init_script][crate::model::linux_node_config::CustomNodeInit::init_script].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::CustomNodeInit;
        /// use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
        /// let x = CustomNodeInit::new().set_init_script(InitScript::default()/* use setters */);
        /// ```
        pub fn set_init_script<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::linux_node_config::custom_node_init::InitScript>,
        {
            self.init_script = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [init_script][crate::model::linux_node_config::CustomNodeInit::init_script].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::CustomNodeInit;
        /// use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
        /// let x = CustomNodeInit::new().set_or_clear_init_script(Some(InitScript::default()/* use setters */));
        /// let x = CustomNodeInit::new().set_or_clear_init_script(None::<InitScript>);
        /// ```
        pub fn set_or_clear_init_script<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::linux_node_config::custom_node_init::InitScript>,
        {
            self.init_script = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for CustomNodeInit {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.LinuxNodeConfig.CustomNodeInit"
        }
    }

    /// Defines additional types related to [CustomNodeInit].
    pub mod custom_node_init {
        #[allow(unused_imports)]
        use super::*;

        /// InitScript provide a simply bash script to be executed on the node.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct InitScript {
            /// The Cloud Storage URI for storing the init script.
            /// Format: gs://BUCKET_NAME/OBJECT_NAME
            /// The service account on the node pool must have read access to the
            /// object.
            /// User can't configure both gcs_uri and gcp_secret_manager_secret_uri.
            pub gcs_uri: std::string::String,

            /// The generation of the init script stored in Gloud Storage.
            /// This is the required field to identify the version of the
            /// init script.
            /// User can get the genetaion from
            /// `gcloud storage objects describe gs://BUCKET_NAME/OBJECT_NAME
            /// --format="value(generation)"` or from the "Version history" tab of the
            /// object in the Cloud Console UI.
            pub gcs_generation: i64,

            /// Optional. The optional arguments line to be passed to the init script.
            pub args: std::vec::Vec<std::string::String>,

            /// The resource name of the secret manager secret hosting the init script.
            /// Both global and regional secrets are supported with format below:
            /// Global secret: projects/{project}/secrets/{secret}/versions/{version}
            /// Regional secret:
            /// projects/{project}/locations/{location}/secrets/{secret}/versions/{version}
            /// Example: projects/1234567890/secrets/script_1/versions/1.
            /// Accept version number only, not support version alias.
            /// User can't configure both gcp_secret_manager_secret_uri and gcs_uri.
            pub gcp_secret_manager_secret_uri: std::string::String,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl InitScript {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [gcs_uri][crate::model::linux_node_config::custom_node_init::InitScript::gcs_uri].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
            /// let x = InitScript::new().set_gcs_uri("example");
            /// ```
            pub fn set_gcs_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.gcs_uri = v.into();
                self
            }

            /// Sets the value of [gcs_generation][crate::model::linux_node_config::custom_node_init::InitScript::gcs_generation].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
            /// let x = InitScript::new().set_gcs_generation(42);
            /// ```
            pub fn set_gcs_generation<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
                self.gcs_generation = v.into();
                self
            }

            /// Sets the value of [args][crate::model::linux_node_config::custom_node_init::InitScript::args].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
            /// let x = InitScript::new().set_args(["a", "b", "c"]);
            /// ```
            pub fn set_args<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.args = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [gcp_secret_manager_secret_uri][crate::model::linux_node_config::custom_node_init::InitScript::gcp_secret_manager_secret_uri].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::custom_node_init::InitScript;
            /// let x = InitScript::new().set_gcp_secret_manager_secret_uri("example");
            /// ```
            pub fn set_gcp_secret_manager_secret_uri<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.gcp_secret_manager_secret_uri = v.into();
                self
            }
        }

        impl wkt::message::Message for InitScript {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.LinuxNodeConfig.CustomNodeInit.InitScript"
            }
        }
    }

    /// Configuration for swap memory on a node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct SwapConfig {
        /// Optional. Enables or disables swap for the node pool.
        pub enabled: std::option::Option<bool>,

        /// Optional. If omitted, swap space is encrypted by default.
        pub encryption_config:
            std::option::Option<crate::model::linux_node_config::swap_config::EncryptionConfig>,

        /// Optional. Defines the backing storage for the swap space.
        /// If omitted, defaults to the 'boot_disk_profile'.
        pub performance_profile:
            std::option::Option<crate::model::linux_node_config::swap_config::PerformanceProfile>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl SwapConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::linux_node_config::SwapConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// let x = SwapConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enabled][crate::model::linux_node_config::SwapConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// let x = SwapConfig::new().set_or_clear_enabled(Some(false));
        /// let x = SwapConfig::new().set_or_clear_enabled(None::<bool>);
        /// ```
        pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = v.map(|x| x.into());
            self
        }

        /// Sets the value of [encryption_config][crate::model::linux_node_config::SwapConfig::encryption_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::EncryptionConfig;
        /// let x = SwapConfig::new().set_encryption_config(EncryptionConfig::default()/* use setters */);
        /// ```
        pub fn set_encryption_config<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::linux_node_config::swap_config::EncryptionConfig>,
        {
            self.encryption_config = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [encryption_config][crate::model::linux_node_config::SwapConfig::encryption_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::EncryptionConfig;
        /// let x = SwapConfig::new().set_or_clear_encryption_config(Some(EncryptionConfig::default()/* use setters */));
        /// let x = SwapConfig::new().set_or_clear_encryption_config(None::<EncryptionConfig>);
        /// ```
        pub fn set_or_clear_encryption_config<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::linux_node_config::swap_config::EncryptionConfig>,
        {
            self.encryption_config = v.map(|x| x.into());
            self
        }

        /// Sets the value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile].
        ///
        /// Note that all the setters affecting `performance_profile` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::BootDiskProfile;
        /// let x = SwapConfig::new().set_performance_profile(Some(
        ///     google_cloud_container_v1::model::linux_node_config::swap_config::PerformanceProfile::BootDiskProfile(BootDiskProfile::default().into())));
        /// ```
        pub fn set_performance_profile<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::linux_node_config::swap_config::PerformanceProfile,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.performance_profile = v.into();
            self
        }

        /// The value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// if it holds a `BootDiskProfile`, `None` if the field is not set or
        /// holds a different branch.
        pub fn boot_disk_profile(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<crate::model::linux_node_config::swap_config::BootDiskProfile>,
        > {
            #[allow(unreachable_patterns)]
            self.performance_profile.as_ref().and_then(|v| match v {
                crate::model::linux_node_config::swap_config::PerformanceProfile::BootDiskProfile(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// to hold a `BootDiskProfile`.
        ///
        /// Note that all the setters affecting `performance_profile` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::BootDiskProfile;
        /// let x = SwapConfig::new().set_boot_disk_profile(BootDiskProfile::default()/* use setters */);
        /// assert!(x.boot_disk_profile().is_some());
        /// assert!(x.ephemeral_local_ssd_profile().is_none());
        /// assert!(x.dedicated_local_ssd_profile().is_none());
        /// ```
        pub fn set_boot_disk_profile<
            T: std::convert::Into<
                    std::boxed::Box<crate::model::linux_node_config::swap_config::BootDiskProfile>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.performance_profile = std::option::Option::Some(
                crate::model::linux_node_config::swap_config::PerformanceProfile::BootDiskProfile(
                    v.into(),
                ),
            );
            self
        }

        /// The value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// if it holds a `EphemeralLocalSsdProfile`, `None` if the field is not set or
        /// holds a different branch.
        pub fn ephemeral_local_ssd_profile(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<
                crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile,
            >,
        > {
            #[allow(unreachable_patterns)]
            self.performance_profile.as_ref().and_then(|v| match v {
                crate::model::linux_node_config::swap_config::PerformanceProfile::EphemeralLocalSsdProfile(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// to hold a `EphemeralLocalSsdProfile`.
        ///
        /// Note that all the setters affecting `performance_profile` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::EphemeralLocalSsdProfile;
        /// let x = SwapConfig::new().set_ephemeral_local_ssd_profile(EphemeralLocalSsdProfile::default()/* use setters */);
        /// assert!(x.ephemeral_local_ssd_profile().is_some());
        /// assert!(x.boot_disk_profile().is_none());
        /// assert!(x.dedicated_local_ssd_profile().is_none());
        /// ```
        pub fn set_ephemeral_local_ssd_profile<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.performance_profile = std::option::Option::Some(
                crate::model::linux_node_config::swap_config::PerformanceProfile::EphemeralLocalSsdProfile(
                    v.into()
                )
            );
            self
        }

        /// The value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// if it holds a `DedicatedLocalSsdProfile`, `None` if the field is not set or
        /// holds a different branch.
        pub fn dedicated_local_ssd_profile(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<
                crate::model::linux_node_config::swap_config::DedicatedLocalSsdProfile,
            >,
        > {
            #[allow(unreachable_patterns)]
            self.performance_profile.as_ref().and_then(|v| match v {
                crate::model::linux_node_config::swap_config::PerformanceProfile::DedicatedLocalSsdProfile(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [performance_profile][crate::model::linux_node_config::SwapConfig::performance_profile]
        /// to hold a `DedicatedLocalSsdProfile`.
        ///
        /// Note that all the setters affecting `performance_profile` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::SwapConfig;
        /// use google_cloud_container_v1::model::linux_node_config::swap_config::DedicatedLocalSsdProfile;
        /// let x = SwapConfig::new().set_dedicated_local_ssd_profile(DedicatedLocalSsdProfile::default()/* use setters */);
        /// assert!(x.dedicated_local_ssd_profile().is_some());
        /// assert!(x.boot_disk_profile().is_none());
        /// assert!(x.ephemeral_local_ssd_profile().is_none());
        /// ```
        pub fn set_dedicated_local_ssd_profile<
            T: std::convert::Into<
                    std::boxed::Box<
                        crate::model::linux_node_config::swap_config::DedicatedLocalSsdProfile,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.performance_profile = std::option::Option::Some(
                crate::model::linux_node_config::swap_config::PerformanceProfile::DedicatedLocalSsdProfile(
                    v.into()
                )
            );
            self
        }
    }

    impl wkt::message::Message for SwapConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.LinuxNodeConfig.SwapConfig"
        }
    }

    /// Defines additional types related to [SwapConfig].
    pub mod swap_config {
        #[allow(unused_imports)]
        use super::*;

        /// Defines encryption settings for the swap space.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct EncryptionConfig {
            /// Optional. If true, swap space will not be encrypted.
            /// Defaults to false (encrypted).
            pub disabled: std::option::Option<bool>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl EncryptionConfig {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [disabled][crate::model::linux_node_config::swap_config::EncryptionConfig::disabled].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::EncryptionConfig;
            /// let x = EncryptionConfig::new().set_disabled(true);
            /// ```
            pub fn set_disabled<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<bool>,
            {
                self.disabled = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [disabled][crate::model::linux_node_config::swap_config::EncryptionConfig::disabled].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::EncryptionConfig;
            /// let x = EncryptionConfig::new().set_or_clear_disabled(Some(false));
            /// let x = EncryptionConfig::new().set_or_clear_disabled(None::<bool>);
            /// ```
            pub fn set_or_clear_disabled<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<bool>,
            {
                self.disabled = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for EncryptionConfig {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.LinuxNodeConfig.SwapConfig.EncryptionConfig"
            }
        }

        /// Swap on the node's boot disk.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct BootDiskProfile {
            /// Optional. Specifies the size of the swap space. If omitted, GKE
            /// determines an optimal size based on node memory.
            pub swap_size: std::option::Option<
                crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize,
            >,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl BootDiskProfile {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::BootDiskProfile::swap_size].
            ///
            /// Note that all the setters affecting `swap_size` are mutually
            /// exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::BootDiskProfile;
            /// use google_cloud_container_v1::model::linux_node_config::swap_config::boot_disk_profile::SwapSize;
            /// let x = BootDiskProfile::new().set_swap_size(Some(SwapSize::SwapSizeGib(42)));
            /// ```
            pub fn set_swap_size<T: std::convert::Into<std::option::Option<crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize>>>(mut self, v: T) -> Self
            {
                self.swap_size = v.into();
                self
            }

            /// The value of [swap_size][crate::model::linux_node_config::swap_config::BootDiskProfile::swap_size]
            /// if it holds a `SwapSizeGib`, `None` if the field is not set or
            /// holds a different branch.
            pub fn swap_size_gib(&self) -> std::option::Option<&i64> {
                #[allow(unreachable_patterns)]
                self.swap_size.as_ref().and_then(|v| match v {
                    crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize::SwapSizeGib(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::BootDiskProfile::swap_size]
            /// to hold a `SwapSizeGib`.
            ///
            /// Note that all the setters affecting `swap_size` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::BootDiskProfile;
            /// let x = BootDiskProfile::new().set_swap_size_gib(42);
            /// assert!(x.swap_size_gib().is_some());
            /// assert!(x.swap_size_percent().is_none());
            /// ```
            pub fn set_swap_size_gib<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
                self.swap_size = std::option::Option::Some(
                    crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize::SwapSizeGib(
                        v.into()
                    )
                );
                self
            }

            /// The value of [swap_size][crate::model::linux_node_config::swap_config::BootDiskProfile::swap_size]
            /// if it holds a `SwapSizePercent`, `None` if the field is not set or
            /// holds a different branch.
            pub fn swap_size_percent(&self) -> std::option::Option<&i32> {
                #[allow(unreachable_patterns)]
                self.swap_size.as_ref().and_then(|v| match v {
                    crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize::SwapSizePercent(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::BootDiskProfile::swap_size]
            /// to hold a `SwapSizePercent`.
            ///
            /// Note that all the setters affecting `swap_size` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::BootDiskProfile;
            /// let x = BootDiskProfile::new().set_swap_size_percent(42);
            /// assert!(x.swap_size_percent().is_some());
            /// assert!(x.swap_size_gib().is_none());
            /// ```
            pub fn set_swap_size_percent<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                self.swap_size = std::option::Option::Some(
                    crate::model::linux_node_config::swap_config::boot_disk_profile::SwapSize::SwapSizePercent(
                        v.into()
                    )
                );
                self
            }
        }

        impl wkt::message::Message for BootDiskProfile {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.LinuxNodeConfig.SwapConfig.BootDiskProfile"
            }
        }

        /// Defines additional types related to [BootDiskProfile].
        pub mod boot_disk_profile {
            #[allow(unused_imports)]
            use super::*;

            /// Optional. Specifies the size of the swap space. If omitted, GKE
            /// determines an optimal size based on node memory.
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum SwapSize {
                /// Specifies the size of the swap space in gibibytes (GiB).
                SwapSizeGib(i64),
                /// Specifies the size of the swap space as a percentage of the boot disk
                /// size.
                SwapSizePercent(i32),
            }
        }

        /// Swap on the local SSD shared with pod ephemeral storage.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct EphemeralLocalSsdProfile {
            /// Specifies the size of the swap space to be provisioned.
            pub swap_size: std::option::Option<
                crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize,
            >,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl EphemeralLocalSsdProfile {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile::swap_size].
            ///
            /// Note that all the setters affecting `swap_size` are mutually
            /// exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::EphemeralLocalSsdProfile;
            /// use google_cloud_container_v1::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize;
            /// let x = EphemeralLocalSsdProfile::new().set_swap_size(Some(SwapSize::SwapSizeGib(42)));
            /// ```
            pub fn set_swap_size<T: std::convert::Into<std::option::Option<crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize>>>(mut self, v: T) -> Self
            {
                self.swap_size = v.into();
                self
            }

            /// The value of [swap_size][crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile::swap_size]
            /// if it holds a `SwapSizeGib`, `None` if the field is not set or
            /// holds a different branch.
            pub fn swap_size_gib(&self) -> std::option::Option<&i64> {
                #[allow(unreachable_patterns)]
                self.swap_size.as_ref().and_then(|v| match v {
                    crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize::SwapSizeGib(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile::swap_size]
            /// to hold a `SwapSizeGib`.
            ///
            /// Note that all the setters affecting `swap_size` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::EphemeralLocalSsdProfile;
            /// let x = EphemeralLocalSsdProfile::new().set_swap_size_gib(42);
            /// assert!(x.swap_size_gib().is_some());
            /// assert!(x.swap_size_percent().is_none());
            /// ```
            pub fn set_swap_size_gib<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
                self.swap_size = std::option::Option::Some(
                    crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize::SwapSizeGib(
                        v.into()
                    )
                );
                self
            }

            /// The value of [swap_size][crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile::swap_size]
            /// if it holds a `SwapSizePercent`, `None` if the field is not set or
            /// holds a different branch.
            pub fn swap_size_percent(&self) -> std::option::Option<&i32> {
                #[allow(unreachable_patterns)]
                self.swap_size.as_ref().and_then(|v| match v {
                    crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize::SwapSizePercent(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [swap_size][crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile::swap_size]
            /// to hold a `SwapSizePercent`.
            ///
            /// Note that all the setters affecting `swap_size` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::EphemeralLocalSsdProfile;
            /// let x = EphemeralLocalSsdProfile::new().set_swap_size_percent(42);
            /// assert!(x.swap_size_percent().is_some());
            /// assert!(x.swap_size_gib().is_none());
            /// ```
            pub fn set_swap_size_percent<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
                self.swap_size = std::option::Option::Some(
                    crate::model::linux_node_config::swap_config::ephemeral_local_ssd_profile::SwapSize::SwapSizePercent(
                        v.into()
                    )
                );
                self
            }
        }

        impl wkt::message::Message for EphemeralLocalSsdProfile {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.LinuxNodeConfig.SwapConfig.EphemeralLocalSsdProfile"
            }
        }

        /// Defines additional types related to [EphemeralLocalSsdProfile].
        pub mod ephemeral_local_ssd_profile {
            #[allow(unused_imports)]
            use super::*;

            /// Specifies the size of the swap space to be provisioned.
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum SwapSize {
                /// Specifies the size of the swap space in gibibytes (GiB).
                SwapSizeGib(i64),
                /// Specifies the size of the swap space as a percentage of the ephemeral
                /// local SSD capacity.
                SwapSizePercent(i32),
            }
        }

        /// Provisions a new, separate local NVMe SSD exclusively for swap.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct DedicatedLocalSsdProfile {
            /// The number of physical local NVMe SSD disks to attach.
            pub disk_count: i64,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl DedicatedLocalSsdProfile {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [disk_count][crate::model::linux_node_config::swap_config::DedicatedLocalSsdProfile::disk_count].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::linux_node_config::swap_config::DedicatedLocalSsdProfile;
            /// let x = DedicatedLocalSsdProfile::new().set_disk_count(42);
            /// ```
            pub fn set_disk_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
                self.disk_count = v.into();
                self
            }
        }

        impl wkt::message::Message for DedicatedLocalSsdProfile {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.LinuxNodeConfig.SwapConfig.DedicatedLocalSsdProfile"
            }
        }

        /// Optional. Defines the backing storage for the swap space.
        /// If omitted, defaults to the 'boot_disk_profile'.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum PerformanceProfile {
            /// Swap on the node's boot disk.
            BootDiskProfile(
                std::boxed::Box<crate::model::linux_node_config::swap_config::BootDiskProfile>,
            ),
            /// Swap on the local SSD shared with pod ephemeral storage.
            EphemeralLocalSsdProfile(
                std::boxed::Box<
                    crate::model::linux_node_config::swap_config::EphemeralLocalSsdProfile,
                >,
            ),
            /// Provisions a new, separate local NVMe SSD exclusively for swap.
            DedicatedLocalSsdProfile(
                std::boxed::Box<
                    crate::model::linux_node_config::swap_config::DedicatedLocalSsdProfile,
                >,
            ),
        }
    }

    /// Configuration for kernel module loading on nodes.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NodeKernelModuleLoading {
        /// Set the node module loading policy for nodes in the node pool.
        pub policy: crate::model::linux_node_config::node_kernel_module_loading::Policy,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NodeKernelModuleLoading {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [policy][crate::model::linux_node_config::NodeKernelModuleLoading::policy].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::NodeKernelModuleLoading;
        /// use google_cloud_container_v1::model::linux_node_config::node_kernel_module_loading::Policy;
        /// let x0 = NodeKernelModuleLoading::new().set_policy(Policy::EnforceSignedModules);
        /// let x1 = NodeKernelModuleLoading::new().set_policy(Policy::DoNotEnforceSignedModules);
        /// ```
        pub fn set_policy<
            T: std::convert::Into<crate::model::linux_node_config::node_kernel_module_loading::Policy>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.policy = v.into();
            self
        }
    }

    impl wkt::message::Message for NodeKernelModuleLoading {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.LinuxNodeConfig.NodeKernelModuleLoading"
        }
    }

    /// Defines additional types related to [NodeKernelModuleLoading].
    pub mod node_kernel_module_loading {
        #[allow(unused_imports)]
        use super::*;

        /// Defines the kernel module loading policy for nodes in the node pool.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Policy {
            /// Default behavior. GKE selects the image based on node type.
            /// For CPU and TPU nodes, the image will not allow loading external
            /// kernel modules.
            /// For GPU nodes, the image will allow loading any module, whether it
            /// is signed or not.
            Unspecified,
            /// Enforced signature verification: Node pools will use a
            /// Container-Optimized OS image configured to allow loading of
            /// *Google-signed* external kernel modules.
            /// Loadpin is enabled but configured to exclude modules, and kernel
            /// module signature checking is enforced.
            EnforceSignedModules,
            /// Mirrors existing DEFAULT behavior:
            /// For CPU and TPU nodes, the image will not allow loading external
            /// kernel modules.
            /// For GPU nodes, the image will allow loading any module, whether it
            /// is signed or not.
            DoNotEnforceSignedModules,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Policy::value] or
            /// [Policy::name].
            UnknownValue(policy::UnknownValue),
        }

        #[doc(hidden)]
        pub mod policy {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Policy {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::EnforceSignedModules => std::option::Option::Some(1),
                    Self::DoNotEnforceSignedModules => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("POLICY_UNSPECIFIED"),
                    Self::EnforceSignedModules => {
                        std::option::Option::Some("ENFORCE_SIGNED_MODULES")
                    }
                    Self::DoNotEnforceSignedModules => {
                        std::option::Option::Some("DO_NOT_ENFORCE_SIGNED_MODULES")
                    }
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Policy {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Policy {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Policy {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::EnforceSignedModules,
                    2 => Self::DoNotEnforceSignedModules,
                    _ => Self::UnknownValue(policy::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Policy {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "POLICY_UNSPECIFIED" => Self::Unspecified,
                    "ENFORCE_SIGNED_MODULES" => Self::EnforceSignedModules,
                    "DO_NOT_ENFORCE_SIGNED_MODULES" => Self::DoNotEnforceSignedModules,
                    _ => Self::UnknownValue(policy::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Policy {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::EnforceSignedModules => serializer.serialize_i32(1),
                    Self::DoNotEnforceSignedModules => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Policy {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Policy>::new(
                    ".google.container.v1.LinuxNodeConfig.NodeKernelModuleLoading.Policy",
                ))
            }
        }
    }

    /// AccurateTimeConfig contains configuration for the accurate time
    /// synchronization feature.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AccurateTimeConfig {
        /// Enables enhanced time synchronization using PTP-KVM.
        pub enable_ptp_kvm_time_sync: std::option::Option<bool>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl AccurateTimeConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enable_ptp_kvm_time_sync][crate::model::linux_node_config::AccurateTimeConfig::enable_ptp_kvm_time_sync].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::AccurateTimeConfig;
        /// let x = AccurateTimeConfig::new().set_enable_ptp_kvm_time_sync(true);
        /// ```
        pub fn set_enable_ptp_kvm_time_sync<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_ptp_kvm_time_sync = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enable_ptp_kvm_time_sync][crate::model::linux_node_config::AccurateTimeConfig::enable_ptp_kvm_time_sync].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::linux_node_config::AccurateTimeConfig;
        /// let x = AccurateTimeConfig::new().set_or_clear_enable_ptp_kvm_time_sync(Some(false));
        /// let x = AccurateTimeConfig::new().set_or_clear_enable_ptp_kvm_time_sync(None::<bool>);
        /// ```
        pub fn set_or_clear_enable_ptp_kvm_time_sync<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_ptp_kvm_time_sync = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for AccurateTimeConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.LinuxNodeConfig.AccurateTimeConfig"
        }
    }

    /// Possible cgroup modes that can be used.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum CgroupMode {
        /// CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used.
        /// The default for the GKE node OS image will be used.
        Unspecified,
        /// CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on
        /// the node image.
        V1,
        /// CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on
        /// the node image.
        V2,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [CgroupMode::value] or
        /// [CgroupMode::name].
        UnknownValue(cgroup_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod cgroup_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl CgroupMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::V1 => std::option::Option::Some(1),
                Self::V2 => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("CGROUP_MODE_UNSPECIFIED"),
                Self::V1 => std::option::Option::Some("CGROUP_MODE_V1"),
                Self::V2 => std::option::Option::Some("CGROUP_MODE_V2"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for CgroupMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for CgroupMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for CgroupMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::V1,
                2 => Self::V2,
                _ => Self::UnknownValue(cgroup_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for CgroupMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CGROUP_MODE_UNSPECIFIED" => Self::Unspecified,
                "CGROUP_MODE_V1" => Self::V1,
                "CGROUP_MODE_V2" => Self::V2,
                _ => Self::UnknownValue(cgroup_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for CgroupMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::V1 => serializer.serialize_i32(1),
                Self::V2 => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for CgroupMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<CgroupMode>::new(
                ".google.container.v1.LinuxNodeConfig.CgroupMode",
            ))
        }
    }

    /// Possible values for transparent hugepage enabled support.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransparentHugepageEnabled {
        /// Default value. GKE will not modify the kernel configuration.
        Unspecified,
        /// Transparent hugepage support for anonymous memory is enabled system wide.
        Always,
        /// Transparent hugepage support for anonymous memory is enabled inside
        /// MADV_HUGEPAGE regions. This is the default kernel configuration.
        Madvise,
        /// Transparent hugepage support for anonymous memory is disabled.
        Never,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransparentHugepageEnabled::value] or
        /// [TransparentHugepageEnabled::name].
        UnknownValue(transparent_hugepage_enabled::UnknownValue),
    }

    #[doc(hidden)]
    pub mod transparent_hugepage_enabled {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl TransparentHugepageEnabled {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Always => std::option::Option::Some(1),
                Self::Madvise => std::option::Option::Some(2),
                Self::Never => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("TRANSPARENT_HUGEPAGE_ENABLED_UNSPECIFIED")
                }
                Self::Always => std::option::Option::Some("TRANSPARENT_HUGEPAGE_ENABLED_ALWAYS"),
                Self::Madvise => std::option::Option::Some("TRANSPARENT_HUGEPAGE_ENABLED_MADVISE"),
                Self::Never => std::option::Option::Some("TRANSPARENT_HUGEPAGE_ENABLED_NEVER"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for TransparentHugepageEnabled {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for TransparentHugepageEnabled {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for TransparentHugepageEnabled {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Always,
                2 => Self::Madvise,
                3 => Self::Never,
                _ => Self::UnknownValue(transparent_hugepage_enabled::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransparentHugepageEnabled {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSPARENT_HUGEPAGE_ENABLED_UNSPECIFIED" => Self::Unspecified,
                "TRANSPARENT_HUGEPAGE_ENABLED_ALWAYS" => Self::Always,
                "TRANSPARENT_HUGEPAGE_ENABLED_MADVISE" => Self::Madvise,
                "TRANSPARENT_HUGEPAGE_ENABLED_NEVER" => Self::Never,
                _ => Self::UnknownValue(transparent_hugepage_enabled::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for TransparentHugepageEnabled {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Always => serializer.serialize_i32(1),
                Self::Madvise => serializer.serialize_i32(2),
                Self::Never => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for TransparentHugepageEnabled {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<TransparentHugepageEnabled>::new(
                    ".google.container.v1.LinuxNodeConfig.TransparentHugepageEnabled",
                ),
            )
        }
    }

    /// Possible values for transparent hugepage defrag support.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum TransparentHugepageDefrag {
        /// Default value. GKE will not modify the kernel configuration.
        Unspecified,
        /// It means that an application requesting THP will stall on allocation
        /// failure and directly reclaim pages and compact memory in an effort to
        /// allocate a THP immediately.
        Always,
        /// It means that an application will wake kswapd in the background to
        /// reclaim pages and wake kcompactd to compact memory so that THP is
        /// available in the near future. It's the responsibility of khugepaged to
        /// then install the THP pages later.
        Defer,
        /// It means that an application will enter direct reclaim and compaction
        /// like always, but only for regions that have used madvise(MADV_HUGEPAGE);
        /// all other regions will wake kswapd in the background to reclaim pages and
        /// wake kcompactd to compact memory so that THP is available in the near
        /// future.
        DeferWithMadvise,
        /// It means that an application will enter direct reclaim like always but
        /// only for regions that are have used madvise(MADV_HUGEPAGE). This is the
        /// default kernel configuration.
        Madvise,
        /// It means that an application will never enter direct reclaim or
        /// compaction.
        Never,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [TransparentHugepageDefrag::value] or
        /// [TransparentHugepageDefrag::name].
        UnknownValue(transparent_hugepage_defrag::UnknownValue),
    }

    #[doc(hidden)]
    pub mod transparent_hugepage_defrag {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl TransparentHugepageDefrag {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Always => std::option::Option::Some(1),
                Self::Defer => std::option::Option::Some(2),
                Self::DeferWithMadvise => std::option::Option::Some(3),
                Self::Madvise => std::option::Option::Some(4),
                Self::Never => std::option::Option::Some(5),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_UNSPECIFIED")
                }
                Self::Always => std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_ALWAYS"),
                Self::Defer => std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_DEFER"),
                Self::DeferWithMadvise => {
                    std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_DEFER_WITH_MADVISE")
                }
                Self::Madvise => std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_MADVISE"),
                Self::Never => std::option::Option::Some("TRANSPARENT_HUGEPAGE_DEFRAG_NEVER"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for TransparentHugepageDefrag {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for TransparentHugepageDefrag {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for TransparentHugepageDefrag {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Always,
                2 => Self::Defer,
                3 => Self::DeferWithMadvise,
                4 => Self::Madvise,
                5 => Self::Never,
                _ => Self::UnknownValue(transparent_hugepage_defrag::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for TransparentHugepageDefrag {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TRANSPARENT_HUGEPAGE_DEFRAG_UNSPECIFIED" => Self::Unspecified,
                "TRANSPARENT_HUGEPAGE_DEFRAG_ALWAYS" => Self::Always,
                "TRANSPARENT_HUGEPAGE_DEFRAG_DEFER" => Self::Defer,
                "TRANSPARENT_HUGEPAGE_DEFRAG_DEFER_WITH_MADVISE" => Self::DeferWithMadvise,
                "TRANSPARENT_HUGEPAGE_DEFRAG_MADVISE" => Self::Madvise,
                "TRANSPARENT_HUGEPAGE_DEFRAG_NEVER" => Self::Never,
                _ => Self::UnknownValue(transparent_hugepage_defrag::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for TransparentHugepageDefrag {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Always => serializer.serialize_i32(1),
                Self::Defer => serializer.serialize_i32(2),
                Self::DeferWithMadvise => serializer.serialize_i32(3),
                Self::Madvise => serializer.serialize_i32(4),
                Self::Never => serializer.serialize_i32(5),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for TransparentHugepageDefrag {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<TransparentHugepageDefrag>::new(
                    ".google.container.v1.LinuxNodeConfig.TransparentHugepageDefrag",
                ),
            )
        }
    }
}

/// Parameters that can be configured on Windows nodes.
/// Windows Node Config that define the parameters that will be used to
/// configure the Windows node pool settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WindowsNodeConfig {
    /// OSVersion specifies the Windows node config to be used on the node.
    pub os_version: crate::model::windows_node_config::OSVersion,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl WindowsNodeConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [os_version][crate::model::WindowsNodeConfig::os_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WindowsNodeConfig;
    /// use google_cloud_container_v1::model::windows_node_config::OSVersion;
    /// let x0 = WindowsNodeConfig::new().set_os_version(OSVersion::Ltsc2019);
    /// let x1 = WindowsNodeConfig::new().set_os_version(OSVersion::Ltsc2022);
    /// ```
    pub fn set_os_version<T: std::convert::Into<crate::model::windows_node_config::OSVersion>>(
        mut self,
        v: T,
    ) -> Self {
        self.os_version = v.into();
        self
    }
}

impl wkt::message::Message for WindowsNodeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.WindowsNodeConfig"
    }
}

/// Defines additional types related to [WindowsNodeConfig].
pub mod windows_node_config {
    #[allow(unused_imports)]
    use super::*;

    /// Possible OS version that can be used.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum OSVersion {
        /// When OSVersion is not specified.
        Unspecified,
        /// LTSC2019 specifies to use LTSC2019 as the Windows Servercore Base Image.
        Ltsc2019,
        /// LTSC2022 specifies to use LTSC2022 as the Windows Servercore Base Image.
        Ltsc2022,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [OSVersion::value] or
        /// [OSVersion::name].
        UnknownValue(os_version::UnknownValue),
    }

    #[doc(hidden)]
    pub mod os_version {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl OSVersion {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Ltsc2019 => std::option::Option::Some(1),
                Self::Ltsc2022 => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("OS_VERSION_UNSPECIFIED"),
                Self::Ltsc2019 => std::option::Option::Some("OS_VERSION_LTSC2019"),
                Self::Ltsc2022 => std::option::Option::Some("OS_VERSION_LTSC2022"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for OSVersion {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for OSVersion {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for OSVersion {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Ltsc2019,
                2 => Self::Ltsc2022,
                _ => Self::UnknownValue(os_version::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for OSVersion {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "OS_VERSION_UNSPECIFIED" => Self::Unspecified,
                "OS_VERSION_LTSC2019" => Self::Ltsc2019,
                "OS_VERSION_LTSC2022" => Self::Ltsc2022,
                _ => Self::UnknownValue(os_version::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for OSVersion {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Ltsc2019 => serializer.serialize_i32(1),
                Self::Ltsc2022 => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for OSVersion {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<OSVersion>::new(
                ".google.container.v1.WindowsNodeConfig.OSVersion",
            ))
        }
    }
}

/// Node kubelet configs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeKubeletConfig {
    /// Control the CPU management policy on the node.
    /// See
    /// <https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/>
    ///
    /// The following values are allowed.
    ///
    /// * "none": the default, which represents the existing scheduling behavior.
    /// * "static": allows pods with certain resource characteristics to be granted
    ///   increased CPU affinity and exclusivity on the node.
    ///   The default value is 'none' if unspecified.
    pub cpu_manager_policy: std::string::String,

    /// Optional. Controls Topology Manager configuration on the node.
    /// For more information, see:
    /// <https://kubernetes.io/docs/tasks/administer-cluster/topology-manager/>
    pub topology_manager: std::option::Option<crate::model::TopologyManager>,

    /// Optional. Controls NUMA-aware Memory Manager configuration on the
    /// node. For more information, see:
    /// <https://kubernetes.io/docs/tasks/administer-cluster/memory-manager/>
    pub memory_manager: std::option::Option<crate::model::MemoryManager>,

    /// Enable CPU CFS quota enforcement for containers that specify CPU limits.
    ///
    /// This option is enabled by default which makes kubelet use CFS quota
    /// (<https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt>) to
    /// enforce container CPU limits. Otherwise, CPU limits will not be enforced at
    /// all.
    ///
    /// Disable this option to mitigate CPU throttling problems while still having
    /// your pods to be in Guaranteed QoS class by specifying the CPU limits.
    ///
    /// The default value is 'true' if unspecified.
    pub cpu_cfs_quota: std::option::Option<wkt::BoolValue>,

    /// Set the CPU CFS quota period value 'cpu.cfs_period_us'.
    ///
    /// The string must be a sequence of decimal numbers, each with optional
    /// fraction and a unit suffix, such as "300ms".
    /// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
    /// The value must be a positive duration between 1ms and 1 second, inclusive.
    pub cpu_cfs_quota_period: std::string::String,

    /// Set the Pod PID limits. See
    /// <https://kubernetes.io/docs/concepts/policy/pid-limiting/#pod-pid-limits>
    ///
    /// Controls the maximum number of processes allowed to run in a pod. The value
    /// must be greater than or equal to 1024 and less than 4194304.
    pub pod_pids_limit: i64,

    /// Enable or disable Kubelet read only port.
    pub insecure_kubelet_readonly_port_enabled: std::option::Option<bool>,

    /// Optional. Defines the percent of disk usage before which image garbage
    /// collection is never run. Lowest disk usage to garbage collect to. The
    /// percent is calculated as this field value out of 100.
    ///
    /// The value must be between 10 and 85, inclusive and smaller than
    /// image_gc_high_threshold_percent.
    ///
    /// The default value is 80 if unspecified.
    pub image_gc_low_threshold_percent: i32,

    /// Optional. Defines the percent of disk usage after which image garbage
    /// collection is always run. The percent is calculated as this field value out
    /// of 100.
    ///
    /// The value must be between 10 and 85, inclusive and greater than
    /// image_gc_low_threshold_percent.
    ///
    /// The default value is 85 if unspecified.
    pub image_gc_high_threshold_percent: i32,

    /// Optional. Defines the minimum age for an unused image before it is garbage
    /// collected.
    ///
    /// The string must be a sequence of decimal numbers, each with optional
    /// fraction and a unit suffix, such as "300s", "1.5h", and "2h45m". Valid time
    /// units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
    ///
    /// The value must be a positive duration less than or equal to 2 minutes.
    ///
    /// The default value is "2m0s" if unspecified.
    pub image_minimum_gc_age: std::string::String,

    /// Optional. Defines the maximum age an image can be unused before it is
    /// garbage collected. The string must be a sequence of decimal numbers, each
    /// with optional fraction and a unit suffix, such as "300s", "1.5h", and
    /// "2h45m". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
    ///
    /// The value must be a positive duration greater than image_minimum_gc_age
    /// or "0s".
    ///
    /// The default value is "0s" if unspecified, which disables this field,
    /// meaning images won't be garbage collected based on being unused for too
    /// long.
    pub image_maximum_gc_age: std::string::String,

    /// Optional. Defines the maximum size of the container log file before it is
    /// rotated. See
    /// <https://kubernetes.io/docs/concepts/cluster-administration/logging/#log-rotation>
    ///
    /// Valid format is positive number + unit, e.g. 100Ki, 10Mi. Valid units are
    /// Ki, Mi, Gi.
    /// The value must be between 10Mi and 500Mi, inclusive.
    ///
    /// Note that the total container log size (container_log_max_size *
    /// container_log_max_files) cannot exceed 1% of the total
    /// storage of the node, to avoid disk pressure caused by log files.
    ///
    /// The default value is 10Mi if unspecified.
    pub container_log_max_size: std::string::String,

    /// Optional. Defines the maximum number of container log files that can be
    /// present for a container. See
    /// <https://kubernetes.io/docs/concepts/cluster-administration/logging/#log-rotation>
    ///
    /// The value must be an integer between 2 and 10, inclusive.
    /// The default value is 5 if unspecified.
    pub container_log_max_files: i32,

    /// Optional. Defines a comma-separated allowlist of unsafe sysctls or sysctl
    /// patterns (ending in `*`).
    ///
    /// The unsafe namespaced sysctl groups are `kernel.shm*`, `kernel.msg*`,
    /// `kernel.sem`, `fs.mqueue.*`, and `net.*`. Leaving this allowlist empty
    /// means they cannot be set on Pods.
    ///
    /// To allow certain sysctls or sysctl patterns to be set on Pods, list them
    /// separated by commas.
    /// For example: `kernel.msg*,net.ipv4.route.min_pmtu`.
    ///
    /// See <https://kubernetes.io/docs/tasks/administer-cluster/sysctl-cluster/>
    /// for more details.
    pub allowed_unsafe_sysctls: std::vec::Vec<std::string::String>,

    /// Optional. eviction_soft is a map of signal names to quantities that defines
    /// soft eviction thresholds. Each signal is compared to its corresponding
    /// threshold to determine if a pod eviction should occur.
    pub eviction_soft: std::option::Option<crate::model::EvictionSignals>,

    /// Optional. eviction_soft_grace_period is a map of signal names to quantities
    /// that defines grace periods for each soft eviction signal. The grace period
    /// is the amount of time that a pod must be under pressure before an eviction
    /// occurs.
    pub eviction_soft_grace_period: std::option::Option<crate::model::EvictionGracePeriod>,

    /// Optional. eviction_minimum_reclaim is a map of signal names to quantities
    /// that defines minimum reclaims, which describe the minimum amount of a given
    /// resource the kubelet will reclaim when performing a pod eviction while that
    /// resource is under pressure.
    pub eviction_minimum_reclaim: std::option::Option<crate::model::EvictionMinimumReclaim>,

    /// Optional. eviction_max_pod_grace_period_seconds is the maximum allowed
    /// grace period (in seconds) to use when terminating pods in response to a
    /// soft eviction threshold being met. This value effectively caps the Pod's
    /// terminationGracePeriodSeconds value during soft evictions. Default: 0.
    /// Range: [0, 300].
    pub eviction_max_pod_grace_period_seconds: i32,

    /// Optional. Defines the maximum number of image pulls in parallel.
    /// The range is 2 to 5, inclusive.
    /// The default value is 2 or 3 depending on the disk type.
    ///
    /// See
    /// <https://kubernetes.io/docs/concepts/containers/images/#maximum-parallel-image-pulls>
    /// for more details.
    pub max_parallel_image_pulls: i32,

    /// Optional. Defines whether to enable single process OOM killer.
    /// If true, will prevent the memory.oom.group flag from being set for
    /// container cgroups in cgroups v2. This causes processes in the container to
    /// be OOM killed individually instead of as a group.
    pub single_process_oom_kill: std::option::Option<bool>,

    /// Optional. Contains configuration options to modify node-level parameters
    /// for container restart behavior.
    pub crash_loop_back_off:
        std::option::Option<crate::model::node_kubelet_config::CrashLoopBackOffConfig>,

    /// Optional. shutdown_grace_period_seconds is the maximum allowed grace period
    /// (in seconds) the total duration that the node should delay the shutdown
    /// during a graceful shutdown. This is the total grace period for pod
    /// termination for both regular and critical pods.
    /// <https://kubernetes.io/docs/concepts/cluster-administration/node-shutdown/>
    /// If set to 0, node will not enable the graceful node shutdown functionality.
    /// This field is only valid for Spot VMs.
    /// Allowed values: 0, 30, 120.
    pub shutdown_grace_period_seconds: std::option::Option<i32>,

    /// Optional. shutdown_grace_period_critical_pods_seconds is the maximum
    /// allowed grace period (in seconds) used to terminate critical pods during a
    /// node shutdown. This value should be <= shutdown_grace_period_seconds, and
    /// is only valid if shutdown_grace_period_seconds is set.
    /// <https://kubernetes.io/docs/concepts/cluster-administration/node-shutdown/>
    /// Range: [0, 120].
    pub shutdown_grace_period_critical_pods_seconds: std::option::Option<i32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeKubeletConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [cpu_manager_policy][crate::model::NodeKubeletConfig::cpu_manager_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_cpu_manager_policy("example");
    /// ```
    pub fn set_cpu_manager_policy<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cpu_manager_policy = v.into();
        self
    }

    /// Sets the value of [topology_manager][crate::model::NodeKubeletConfig::topology_manager].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::TopologyManager;
    /// let x = NodeKubeletConfig::new().set_topology_manager(TopologyManager::default()/* use setters */);
    /// ```
    pub fn set_topology_manager<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TopologyManager>,
    {
        self.topology_manager = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [topology_manager][crate::model::NodeKubeletConfig::topology_manager].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::TopologyManager;
    /// let x = NodeKubeletConfig::new().set_or_clear_topology_manager(Some(TopologyManager::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_topology_manager(None::<TopologyManager>);
    /// ```
    pub fn set_or_clear_topology_manager<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TopologyManager>,
    {
        self.topology_manager = v.map(|x| x.into());
        self
    }

    /// Sets the value of [memory_manager][crate::model::NodeKubeletConfig::memory_manager].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::MemoryManager;
    /// let x = NodeKubeletConfig::new().set_memory_manager(MemoryManager::default()/* use setters */);
    /// ```
    pub fn set_memory_manager<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MemoryManager>,
    {
        self.memory_manager = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [memory_manager][crate::model::NodeKubeletConfig::memory_manager].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::MemoryManager;
    /// let x = NodeKubeletConfig::new().set_or_clear_memory_manager(Some(MemoryManager::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_memory_manager(None::<MemoryManager>);
    /// ```
    pub fn set_or_clear_memory_manager<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MemoryManager>,
    {
        self.memory_manager = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cpu_cfs_quota][crate::model::NodeKubeletConfig::cpu_cfs_quota].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use wkt::BoolValue;
    /// let x = NodeKubeletConfig::new().set_cpu_cfs_quota(BoolValue::default()/* use setters */);
    /// ```
    pub fn set_cpu_cfs_quota<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::BoolValue>,
    {
        self.cpu_cfs_quota = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cpu_cfs_quota][crate::model::NodeKubeletConfig::cpu_cfs_quota].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use wkt::BoolValue;
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_cfs_quota(Some(BoolValue::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_cfs_quota(None::<BoolValue>);
    /// ```
    pub fn set_or_clear_cpu_cfs_quota<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::BoolValue>,
    {
        self.cpu_cfs_quota = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cpu_cfs_quota_period][crate::model::NodeKubeletConfig::cpu_cfs_quota_period].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_cpu_cfs_quota_period("example");
    /// ```
    pub fn set_cpu_cfs_quota_period<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cpu_cfs_quota_period = v.into();
        self
    }

    /// Sets the value of [pod_pids_limit][crate::model::NodeKubeletConfig::pod_pids_limit].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_pod_pids_limit(42);
    /// ```
    pub fn set_pod_pids_limit<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.pod_pids_limit = v.into();
        self
    }

    /// Sets the value of [insecure_kubelet_readonly_port_enabled][crate::model::NodeKubeletConfig::insecure_kubelet_readonly_port_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_insecure_kubelet_readonly_port_enabled(true);
    /// ```
    pub fn set_insecure_kubelet_readonly_port_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.insecure_kubelet_readonly_port_enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [insecure_kubelet_readonly_port_enabled][crate::model::NodeKubeletConfig::insecure_kubelet_readonly_port_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_insecure_kubelet_readonly_port_enabled(Some(false));
    /// let x = NodeKubeletConfig::new().set_or_clear_insecure_kubelet_readonly_port_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_insecure_kubelet_readonly_port_enabled<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.insecure_kubelet_readonly_port_enabled = v.map(|x| x.into());
        self
    }

    /// Sets the value of [image_gc_low_threshold_percent][crate::model::NodeKubeletConfig::image_gc_low_threshold_percent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_image_gc_low_threshold_percent(42);
    /// ```
    pub fn set_image_gc_low_threshold_percent<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.image_gc_low_threshold_percent = v.into();
        self
    }

    /// Sets the value of [image_gc_high_threshold_percent][crate::model::NodeKubeletConfig::image_gc_high_threshold_percent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_image_gc_high_threshold_percent(42);
    /// ```
    pub fn set_image_gc_high_threshold_percent<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.image_gc_high_threshold_percent = v.into();
        self
    }

    /// Sets the value of [image_minimum_gc_age][crate::model::NodeKubeletConfig::image_minimum_gc_age].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_image_minimum_gc_age("example");
    /// ```
    pub fn set_image_minimum_gc_age<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.image_minimum_gc_age = v.into();
        self
    }

    /// Sets the value of [image_maximum_gc_age][crate::model::NodeKubeletConfig::image_maximum_gc_age].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_image_maximum_gc_age("example");
    /// ```
    pub fn set_image_maximum_gc_age<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.image_maximum_gc_age = v.into();
        self
    }

    /// Sets the value of [container_log_max_size][crate::model::NodeKubeletConfig::container_log_max_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_container_log_max_size("example");
    /// ```
    pub fn set_container_log_max_size<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.container_log_max_size = v.into();
        self
    }

    /// Sets the value of [container_log_max_files][crate::model::NodeKubeletConfig::container_log_max_files].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_container_log_max_files(42);
    /// ```
    pub fn set_container_log_max_files<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.container_log_max_files = v.into();
        self
    }

    /// Sets the value of [allowed_unsafe_sysctls][crate::model::NodeKubeletConfig::allowed_unsafe_sysctls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_allowed_unsafe_sysctls(["a", "b", "c"]);
    /// ```
    pub fn set_allowed_unsafe_sysctls<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.allowed_unsafe_sysctls = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [eviction_soft][crate::model::NodeKubeletConfig::eviction_soft].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionSignals;
    /// let x = NodeKubeletConfig::new().set_eviction_soft(EvictionSignals::default()/* use setters */);
    /// ```
    pub fn set_eviction_soft<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::EvictionSignals>,
    {
        self.eviction_soft = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [eviction_soft][crate::model::NodeKubeletConfig::eviction_soft].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionSignals;
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_soft(Some(EvictionSignals::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_soft(None::<EvictionSignals>);
    /// ```
    pub fn set_or_clear_eviction_soft<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::EvictionSignals>,
    {
        self.eviction_soft = v.map(|x| x.into());
        self
    }

    /// Sets the value of [eviction_soft_grace_period][crate::model::NodeKubeletConfig::eviction_soft_grace_period].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = NodeKubeletConfig::new().set_eviction_soft_grace_period(EvictionGracePeriod::default()/* use setters */);
    /// ```
    pub fn set_eviction_soft_grace_period<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::EvictionGracePeriod>,
    {
        self.eviction_soft_grace_period = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [eviction_soft_grace_period][crate::model::NodeKubeletConfig::eviction_soft_grace_period].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_soft_grace_period(Some(EvictionGracePeriod::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_soft_grace_period(None::<EvictionGracePeriod>);
    /// ```
    pub fn set_or_clear_eviction_soft_grace_period<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::EvictionGracePeriod>,
    {
        self.eviction_soft_grace_period = v.map(|x| x.into());
        self
    }

    /// Sets the value of [eviction_minimum_reclaim][crate::model::NodeKubeletConfig::eviction_minimum_reclaim].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = NodeKubeletConfig::new().set_eviction_minimum_reclaim(EvictionMinimumReclaim::default()/* use setters */);
    /// ```
    pub fn set_eviction_minimum_reclaim<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::EvictionMinimumReclaim>,
    {
        self.eviction_minimum_reclaim = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [eviction_minimum_reclaim][crate::model::NodeKubeletConfig::eviction_minimum_reclaim].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_minimum_reclaim(Some(EvictionMinimumReclaim::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_eviction_minimum_reclaim(None::<EvictionMinimumReclaim>);
    /// ```
    pub fn set_or_clear_eviction_minimum_reclaim<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::EvictionMinimumReclaim>,
    {
        self.eviction_minimum_reclaim = v.map(|x| x.into());
        self
    }

    /// Sets the value of [eviction_max_pod_grace_period_seconds][crate::model::NodeKubeletConfig::eviction_max_pod_grace_period_seconds].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_eviction_max_pod_grace_period_seconds(42);
    /// ```
    pub fn set_eviction_max_pod_grace_period_seconds<T: std::convert::Into<i32>>(
        mut self,
        v: T,
    ) -> Self {
        self.eviction_max_pod_grace_period_seconds = v.into();
        self
    }

    /// Sets the value of [max_parallel_image_pulls][crate::model::NodeKubeletConfig::max_parallel_image_pulls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_max_parallel_image_pulls(42);
    /// ```
    pub fn set_max_parallel_image_pulls<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_parallel_image_pulls = v.into();
        self
    }

    /// Sets the value of [single_process_oom_kill][crate::model::NodeKubeletConfig::single_process_oom_kill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_single_process_oom_kill(true);
    /// ```
    pub fn set_single_process_oom_kill<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.single_process_oom_kill = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [single_process_oom_kill][crate::model::NodeKubeletConfig::single_process_oom_kill].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_single_process_oom_kill(Some(false));
    /// let x = NodeKubeletConfig::new().set_or_clear_single_process_oom_kill(None::<bool>);
    /// ```
    pub fn set_or_clear_single_process_oom_kill<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.single_process_oom_kill = v.map(|x| x.into());
        self
    }

    /// Sets the value of [crash_loop_back_off][crate::model::NodeKubeletConfig::crash_loop_back_off].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::node_kubelet_config::CrashLoopBackOffConfig;
    /// let x = NodeKubeletConfig::new().set_crash_loop_back_off(CrashLoopBackOffConfig::default()/* use setters */);
    /// ```
    pub fn set_crash_loop_back_off<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_kubelet_config::CrashLoopBackOffConfig>,
    {
        self.crash_loop_back_off = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [crash_loop_back_off][crate::model::NodeKubeletConfig::crash_loop_back_off].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// use google_cloud_container_v1::model::node_kubelet_config::CrashLoopBackOffConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_crash_loop_back_off(Some(CrashLoopBackOffConfig::default()/* use setters */));
    /// let x = NodeKubeletConfig::new().set_or_clear_crash_loop_back_off(None::<CrashLoopBackOffConfig>);
    /// ```
    pub fn set_or_clear_crash_loop_back_off<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_kubelet_config::CrashLoopBackOffConfig>,
    {
        self.crash_loop_back_off = v.map(|x| x.into());
        self
    }

    /// Sets the value of [shutdown_grace_period_seconds][crate::model::NodeKubeletConfig::shutdown_grace_period_seconds].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_shutdown_grace_period_seconds(42);
    /// ```
    pub fn set_shutdown_grace_period_seconds<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.shutdown_grace_period_seconds = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [shutdown_grace_period_seconds][crate::model::NodeKubeletConfig::shutdown_grace_period_seconds].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_shutdown_grace_period_seconds(Some(42));
    /// let x = NodeKubeletConfig::new().set_or_clear_shutdown_grace_period_seconds(None::<i32>);
    /// ```
    pub fn set_or_clear_shutdown_grace_period_seconds<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.shutdown_grace_period_seconds = v.map(|x| x.into());
        self
    }

    /// Sets the value of [shutdown_grace_period_critical_pods_seconds][crate::model::NodeKubeletConfig::shutdown_grace_period_critical_pods_seconds].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_shutdown_grace_period_critical_pods_seconds(42);
    /// ```
    pub fn set_shutdown_grace_period_critical_pods_seconds<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.shutdown_grace_period_critical_pods_seconds = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [shutdown_grace_period_critical_pods_seconds][crate::model::NodeKubeletConfig::shutdown_grace_period_critical_pods_seconds].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_shutdown_grace_period_critical_pods_seconds(Some(42));
    /// let x = NodeKubeletConfig::new().set_or_clear_shutdown_grace_period_critical_pods_seconds(None::<i32>);
    /// ```
    pub fn set_or_clear_shutdown_grace_period_critical_pods_seconds<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.shutdown_grace_period_critical_pods_seconds = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodeKubeletConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeKubeletConfig"
    }
}

/// Defines additional types related to [NodeKubeletConfig].
pub mod node_kubelet_config {
    #[allow(unused_imports)]
    use super::*;

    /// Contains config to modify node-level parameters for container restart
    /// behavior.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CrashLoopBackOffConfig {
        /// Optional. The maximum duration the backoff delay can accrue to for
        /// container restarts, minimum 1 second, maximum 300 seconds. If not set,
        /// defaults to the internal crashloopbackoff maximum.
        ///
        /// The string must be a sequence of decimal numbers, each with optional
        /// fraction and a unit suffix, such as "300ms".
        /// Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
        ///
        /// See
        /// <https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#configurable-container-restart-delay>
        /// for more details.
        pub max_container_restart_period: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl CrashLoopBackOffConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [max_container_restart_period][crate::model::node_kubelet_config::CrashLoopBackOffConfig::max_container_restart_period].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_kubelet_config::CrashLoopBackOffConfig;
        /// let x = CrashLoopBackOffConfig::new().set_max_container_restart_period("example");
        /// ```
        pub fn set_max_container_restart_period<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.max_container_restart_period = v.into();
            self
        }
    }

    impl wkt::message::Message for CrashLoopBackOffConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodeKubeletConfig.CrashLoopBackOffConfig"
        }
    }
}

/// TopologyManager defines the configuration options for Topology Manager
/// feature. See
/// <https://kubernetes.io/docs/tasks/administer-cluster/topology-manager/>
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TopologyManager {
    /// Configures the strategy for resource alignment.
    /// Allowed values are:
    ///
    /// * none: the default policy, and does not perform any topology alignment.
    /// * restricted: the topology manager stores the preferred NUMA node affinity
    ///   for the container, and will reject the pod if the affinity if not
    ///   preferred.
    /// * best-effort: the topology manager stores the preferred NUMA node affinity
    ///   for the container. If the affinity is not preferred, the topology manager
    ///   will admit the pod to the node anyway.
    /// * single-numa-node: the topology manager determines if the single NUMA node
    ///   affinity is possible. If it is, Topology Manager will store this and the
    ///   Hint Providers can then use this information when making the resource
    ///   allocation decision. If, however, this is not possible then the
    ///   Topology Manager will reject the pod from the node. This will result in a
    ///   pod in a Terminated state with a pod admission failure.
    ///
    /// The default policy value is 'none' if unspecified.
    /// Details about each strategy can be found
    /// [here](https://kubernetes.io/docs/tasks/administer-cluster/topology-manager/#topology-manager-policies).
    pub policy: std::string::String,

    /// The Topology Manager aligns resources in following scopes:
    ///
    /// * container
    /// * pod
    ///
    /// The default scope is 'container' if unspecified.
    /// See
    /// <https://kubernetes.io/docs/tasks/administer-cluster/topology-manager/#topology-manager-scopes>
    pub scope: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TopologyManager {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [policy][crate::model::TopologyManager::policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TopologyManager;
    /// let x = TopologyManager::new().set_policy("example");
    /// ```
    pub fn set_policy<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.policy = v.into();
        self
    }

    /// Sets the value of [scope][crate::model::TopologyManager::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TopologyManager;
    /// let x = TopologyManager::new().set_scope("example");
    /// ```
    pub fn set_scope<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.scope = v.into();
        self
    }
}

impl wkt::message::Message for TopologyManager {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.TopologyManager"
    }
}

/// The option enables the Kubernetes NUMA-aware Memory Manager feature.
/// Detailed description about the feature can be found
/// [here](https://kubernetes.io/docs/tasks/administer-cluster/memory-manager/).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MemoryManager {
    /// Controls the memory management policy on the Node.
    /// See
    /// <https://kubernetes.io/docs/tasks/administer-cluster/memory-manager/#policies>
    ///
    /// The following values are allowed.
    ///
    /// * "none"
    /// * "static"
    ///   The default value is 'none' if unspecified.
    pub policy: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MemoryManager {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [policy][crate::model::MemoryManager::policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MemoryManager;
    /// let x = MemoryManager::new().set_policy("example");
    /// ```
    pub fn set_policy<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.policy = v.into();
        self
    }
}

impl wkt::message::Message for MemoryManager {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MemoryManager"
    }
}

/// Eviction signals are the current state of a particular resource at a specific
/// point in time. The kubelet uses eviction signals to make eviction decisions
/// by comparing the signals to eviction thresholds, which are the minimum amount
/// of the resource that should be available on the node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EvictionSignals {
    /// Optional. Memory available (i.e. capacity - workingSet), in bytes. Defines
    /// the amount of "memory.available" signal in kubelet. Default is unset, if
    /// not specified in the kubelet config. Format: positive number + unit, e.g.
    /// 100Ki, 10Mi, 5Gi. Valid units are Ki, Mi, Gi. Must be >= 100Mi and <= 50%
    /// of the node's memory. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub memory_available: std::string::String,

    /// Optional. Amount of storage available on filesystem that kubelet uses for
    /// volumes, daemon logs, etc. Defines the amount of "nodefs.available" signal
    /// in kubelet. Default is unset, if not specified in the kubelet config. It
    /// takses percentage value for now. Sample format: "30%". Must be >= 10% and
    /// <= 50%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_available: std::string::String,

    /// Optional. Amount of inodes available on filesystem that kubelet uses for
    /// volumes, daemon logs, etc. Defines the amount of "nodefs.inodesFree" signal
    /// in kubelet. Default is unset, if not specified in the kubelet config. Linux
    /// only. It takses percentage value for now. Sample format: "30%". Must be >=
    /// 5% and <= 50%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_inodes_free: std::string::String,

    /// Optional. Amount of storage available on filesystem that container runtime
    /// uses for storing images layers. If the container filesystem and image
    /// filesystem are not separate, then imagefs can store both image layers and
    /// writeable layers. Defines the amount of "imagefs.available" signal in
    /// kubelet. Default is unset, if not specified in the kubelet config. It
    /// takses percentage value for now. Sample format: "30%". Must be >= 15% and
    /// <= 50%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_available: std::string::String,

    /// Optional. Amount of inodes available on filesystem that container runtime
    /// uses for storing images layers. Defines the amount of "imagefs.inodesFree"
    /// signal in kubelet. Default is unset, if not specified in the kubelet
    /// config. Linux only. It takses percentage value for now. Sample format:
    /// "30%". Must be >= 5% and <= 50%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_inodes_free: std::string::String,

    /// Optional. Amount of PID available for pod allocation. Defines the amount of
    /// "pid.available" signal in kubelet. Default is unset, if not specified in
    /// the kubelet config. It takses percentage value for now. Sample format:
    /// "30%". Must be >= 10% and <= 50%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub pid_available: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EvictionSignals {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [memory_available][crate::model::EvictionSignals::memory_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_memory_available("example");
    /// ```
    pub fn set_memory_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.memory_available = v.into();
        self
    }

    /// Sets the value of [nodefs_available][crate::model::EvictionSignals::nodefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_nodefs_available("example");
    /// ```
    pub fn set_nodefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_available = v.into();
        self
    }

    /// Sets the value of [nodefs_inodes_free][crate::model::EvictionSignals::nodefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_nodefs_inodes_free("example");
    /// ```
    pub fn set_nodefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [imagefs_available][crate::model::EvictionSignals::imagefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_imagefs_available("example");
    /// ```
    pub fn set_imagefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_available = v.into();
        self
    }

    /// Sets the value of [imagefs_inodes_free][crate::model::EvictionSignals::imagefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_imagefs_inodes_free("example");
    /// ```
    pub fn set_imagefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [pid_available][crate::model::EvictionSignals::pid_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionSignals;
    /// let x = EvictionSignals::new().set_pid_available("example");
    /// ```
    pub fn set_pid_available<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.pid_available = v.into();
        self
    }
}

impl wkt::message::Message for EvictionSignals {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.EvictionSignals"
    }
}

/// Eviction grace periods are grace periods for each eviction signal.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EvictionGracePeriod {
    /// Optional. Grace period for eviction due to memory available signal. Sample
    /// format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub memory_available: std::string::String,

    /// Optional. Grace period for eviction due to nodefs available signal. Sample
    /// format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_available: std::string::String,

    /// Optional. Grace period for eviction due to nodefs inodes free signal.
    /// Sample format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_inodes_free: std::string::String,

    /// Optional. Grace period for eviction due to imagefs available signal. Sample
    /// format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_available: std::string::String,

    /// Optional. Grace period for eviction due to imagefs inodes free signal.
    /// Sample format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_inodes_free: std::string::String,

    /// Optional. Grace period for eviction due to pid available signal. Sample
    /// format: "10s". Must be >= 0. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub pid_available: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EvictionGracePeriod {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [memory_available][crate::model::EvictionGracePeriod::memory_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_memory_available("example");
    /// ```
    pub fn set_memory_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.memory_available = v.into();
        self
    }

    /// Sets the value of [nodefs_available][crate::model::EvictionGracePeriod::nodefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_nodefs_available("example");
    /// ```
    pub fn set_nodefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_available = v.into();
        self
    }

    /// Sets the value of [nodefs_inodes_free][crate::model::EvictionGracePeriod::nodefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_nodefs_inodes_free("example");
    /// ```
    pub fn set_nodefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [imagefs_available][crate::model::EvictionGracePeriod::imagefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_imagefs_available("example");
    /// ```
    pub fn set_imagefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_available = v.into();
        self
    }

    /// Sets the value of [imagefs_inodes_free][crate::model::EvictionGracePeriod::imagefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_imagefs_inodes_free("example");
    /// ```
    pub fn set_imagefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [pid_available][crate::model::EvictionGracePeriod::pid_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionGracePeriod;
    /// let x = EvictionGracePeriod::new().set_pid_available("example");
    /// ```
    pub fn set_pid_available<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.pid_available = v.into();
        self
    }
}

impl wkt::message::Message for EvictionGracePeriod {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.EvictionGracePeriod"
    }
}

/// Eviction minimum reclaims are the resource amounts of minimum reclaims for
/// each eviction signal.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EvictionMinimumReclaim {
    /// Optional. Minimum reclaim for eviction due to memory available signal. Only
    /// take percentage value for now. Sample format: "10%". Must be <=10%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub memory_available: std::string::String,

    /// Optional. Minimum reclaim for eviction due to nodefs available signal. Only
    /// take percentage value for now. Sample format: "10%". Must be <=10%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_available: std::string::String,

    /// Optional. Minimum reclaim for eviction due to nodefs inodes free signal.
    /// Only take percentage value for now. Sample format: "10%". Must be <=10%.
    /// See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub nodefs_inodes_free: std::string::String,

    /// Optional. Minimum reclaim for eviction due to imagefs available signal.
    /// Only take percentage value for now. Sample format: "10%". Must be <=10%.
    /// See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_available: std::string::String,

    /// Optional. Minimum reclaim for eviction due to imagefs inodes free signal.
    /// Only take percentage value for now. Sample format: "10%". Must be <=10%.
    /// See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub imagefs_inodes_free: std::string::String,

    /// Optional. Minimum reclaim for eviction due to pid available signal. Only
    /// take percentage value for now. Sample format: "10%". Must be <=10%. See
    /// <https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/#eviction-signals>
    pub pid_available: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EvictionMinimumReclaim {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [memory_available][crate::model::EvictionMinimumReclaim::memory_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_memory_available("example");
    /// ```
    pub fn set_memory_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.memory_available = v.into();
        self
    }

    /// Sets the value of [nodefs_available][crate::model::EvictionMinimumReclaim::nodefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_nodefs_available("example");
    /// ```
    pub fn set_nodefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_available = v.into();
        self
    }

    /// Sets the value of [nodefs_inodes_free][crate::model::EvictionMinimumReclaim::nodefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_nodefs_inodes_free("example");
    /// ```
    pub fn set_nodefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.nodefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [imagefs_available][crate::model::EvictionMinimumReclaim::imagefs_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_imagefs_available("example");
    /// ```
    pub fn set_imagefs_available<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_available = v.into();
        self
    }

    /// Sets the value of [imagefs_inodes_free][crate::model::EvictionMinimumReclaim::imagefs_inodes_free].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_imagefs_inodes_free("example");
    /// ```
    pub fn set_imagefs_inodes_free<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.imagefs_inodes_free = v.into();
        self
    }

    /// Sets the value of [pid_available][crate::model::EvictionMinimumReclaim::pid_available].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EvictionMinimumReclaim;
    /// let x = EvictionMinimumReclaim::new().set_pid_available("example");
    /// ```
    pub fn set_pid_available<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.pid_available = v.into();
        self
    }
}

impl wkt::message::Message for EvictionMinimumReclaim {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.EvictionMinimumReclaim"
    }
}

/// Parameters that describe the nodes in a cluster.
///
/// GKE Autopilot clusters do not
/// recognize parameters in `NodeConfig`. Use
/// [AutoprovisioningNodePoolDefaults][google.container.v1.AutoprovisioningNodePoolDefaults]
/// instead.
///
/// [google.container.v1.AutoprovisioningNodePoolDefaults]: crate::model::AutoprovisioningNodePoolDefaults
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeConfig {
    /// The name of a Google Compute Engine [machine
    /// type](https://cloud.google.com/compute/docs/machine-types)
    ///
    /// If unspecified, the default machine type is `e2-medium`.
    pub machine_type: std::string::String,

    /// Size of the disk attached to each node, specified in GB.
    /// The smallest allowed disk size is 10GB.
    ///
    /// If unspecified, the default disk size is 100GB.
    pub disk_size_gb: i32,

    /// The set of Google API scopes to be made available on all of the
    /// node VMs under the "default" service account.
    ///
    /// The following scopes are recommended, but not required, and by default are
    /// not included:
    ///
    /// * `<https://www.googleapis.com/auth/compute>` is required for mounting
    ///   persistent storage on your nodes.
    /// * `<https://www.googleapis.com/auth/devstorage.read_only>` is required for
    ///   communicating with **gcr.io**
    ///   (the [Artifact Registry](https://cloud.google.com/artifact-registry/)).
    ///
    /// If unspecified, no scopes are added, unless Cloud Logging or Cloud
    /// Monitoring are enabled, in which case their required scopes will be added.
    pub oauth_scopes: std::vec::Vec<std::string::String>,

    /// The Google Cloud Platform Service Account to be used by the node VMs.
    /// Specify the email address of the Service Account; otherwise, if no Service
    /// Account is specified, the "default" service account is used.
    pub service_account: std::string::String,

    /// The metadata key/value pairs assigned to instances in the cluster.
    ///
    /// Keys must conform to the regexp `[a-zA-Z0-9-_]+` and be less than 128 bytes
    /// in length. These are reflected as part of a URL in the metadata server.
    /// Additionally, to avoid ambiguity, keys must not conflict with any other
    /// metadata keys for the project or be one of the reserved keys:
    ///
    /// - "cluster-location"
    /// - "cluster-name"
    /// - "cluster-uid"
    /// - "configure-sh"
    /// - "containerd-configure-sh"
    /// - "enable-os-login"
    /// - "gci-ensure-gke-docker"
    /// - "gci-metrics-enabled"
    /// - "gci-update-strategy"
    /// - "instance-template"
    /// - "kube-env"
    /// - "startup-script"
    /// - "user-data"
    /// - "disable-address-manager"
    /// - "windows-startup-script-ps1"
    /// - "common-psm1"
    /// - "k8s-node-setup-psm1"
    /// - "install-ssh-psm1"
    /// - "user-profile-psm1"
    ///
    /// Values are free-form strings, and only have meaning as interpreted by
    /// the image running in the instance. The only restriction placed on them is
    /// that each value's size must be less than or equal to 32 KB.
    ///
    /// The total size of all keys and values must be less than 512 KB.
    pub metadata: std::collections::HashMap<std::string::String, std::string::String>,

    /// The image type to use for this node. Note that for a given image type,
    /// the latest version of it will be used. Please see
    /// <https://cloud.google.com/kubernetes-engine/docs/concepts/node-images>
    /// for available image types.
    pub image_type: std::string::String,

    /// The node image configuration to use for this node pool.  Note that this is
    /// only applicable for node pools using image_type=CUSTOM.
    pub node_image_config: std::option::Option<crate::model::CustomImageConfig>,

    /// The Kubernetes labels (key/value pairs) to apply to each node. The values
    /// in this field are added to the set of default labels Kubernetes applies to
    /// nodes.
    ///
    /// This field has the following restrictions:
    ///
    /// * Labels must use a valid Kubernetes syntax and character set, as defined
    ///   in
    ///   <https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#syntax-and-character-set>.
    /// * This field supports up to 1,024 total characters in a single request.
    ///
    /// Depending on the Kubernetes version, keys in this field might conflict with
    /// the keys of the default labels, which might change which of your labels
    /// are applied to the nodes. Assume that the behavior is unpredictable and
    /// avoid label key conflicts. For more information about the default labels,
    /// see:
    /// <https://kubernetes.io/docs/reference/labels-annotations-taints/>
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// The number of local SSD disks to be attached to the node.
    ///
    /// The limit for this value is dependent upon the maximum number of
    /// disks available on a machine per zone. See:
    /// <https://cloud.google.com/compute/docs/disks/local-ssd>
    /// for more information.
    pub local_ssd_count: i32,

    /// The list of instance tags applied to all nodes. Tags are used to identify
    /// valid sources or targets for network firewalls and are specified by
    /// the client during cluster or node pool creation. Each tag within the list
    /// must comply with RFC1035.
    pub tags: std::vec::Vec<std::string::String>,

    /// Whether the nodes are created as preemptible VM instances. See:
    /// <https://cloud.google.com/compute/docs/instances/preemptible>
    /// for more information about preemptible VM instances.
    pub preemptible: bool,

    /// A list of hardware accelerators to be attached to each node.
    /// See
    /// <https://cloud.google.com/compute/docs/gpus>
    /// for more information about support for GPUs.
    pub accelerators: std::vec::Vec<crate::model::AcceleratorConfig>,

    /// Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or
    /// 'pd-balanced')
    ///
    /// If unspecified, the default disk type is 'pd-standard'
    pub disk_type: std::string::String,

    /// Minimum CPU platform to be used by this instance. The instance may be
    /// scheduled on the specified or newer CPU platform. Applicable values are the
    /// friendly names of CPU platforms, such as
    /// `minCpuPlatform: "Intel Haswell"` or
    /// `minCpuPlatform: "Intel Sandy Bridge"`. For more
    /// information, read [how to specify min CPU
    /// platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform)
    pub min_cpu_platform: std::string::String,

    /// The workload metadata configuration for this node.
    pub workload_metadata_config: std::option::Option<crate::model::WorkloadMetadataConfig>,

    /// List of kubernetes taints to be applied to each node.
    ///
    /// For more information, including usage and the valid values, see:
    /// <https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/>
    pub taints: std::vec::Vec<crate::model::NodeTaint>,

    /// Sandbox configuration for this node.
    pub sandbox_config: std::option::Option<crate::model::SandboxConfig>,

    /// Setting this field will assign instances of this
    /// pool to run on the specified node group. This is useful for running
    /// workloads on [sole tenant
    /// nodes](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes).
    pub node_group: std::string::String,

    /// The optional reservation affinity. Setting this field will apply
    /// the specified [Zonal Compute
    /// Reservation](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources)
    /// to this node pool.
    pub reservation_affinity: std::option::Option<crate::model::ReservationAffinity>,

    /// Shielded Instance options.
    pub shielded_instance_config: std::option::Option<crate::model::ShieldedInstanceConfig>,

    /// Parameters that can be configured on Linux nodes.
    pub linux_node_config: std::option::Option<crate::model::LinuxNodeConfig>,

    /// Node kubelet configs.
    pub kubelet_config: std::option::Option<crate::model::NodeKubeletConfig>,

    /// The Customer Managed Encryption Key used to encrypt the boot disk attached
    /// to each node in the node pool. This should be of the form
    /// projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME].
    /// For more information about protecting resources with Cloud KMS Keys please
    /// see:
    /// <https://cloud.google.com/compute/docs/disks/customer-managed-encryption>
    pub boot_disk_kms_key: std::string::String,

    /// Google Container File System (image streaming) configs.
    pub gcfs_config: std::option::Option<crate::model::GcfsConfig>,

    /// Advanced features for the Compute Engine VM.
    pub advanced_machine_features: std::option::Option<crate::model::AdvancedMachineFeatures>,

    /// Enable or disable gvnic in the node pool.
    pub gvnic: std::option::Option<crate::model::VirtualNIC>,

    /// Spot flag for enabling Spot VM, which is a rebrand of
    /// the existing preemptible flag.
    pub spot: bool,

    /// Confidential nodes config.
    /// All the nodes in the node pool will be Confidential VM once enabled.
    pub confidential_nodes: std::option::Option<crate::model::ConfidentialNodes>,

    /// Enable or disable NCCL fast socket for the node pool.
    pub fast_socket: std::option::Option<crate::model::FastSocket>,

    /// The resource labels for the node pool to use to annotate any related
    /// Google Compute Engine resources.
    pub resource_labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Logging configuration.
    pub logging_config: std::option::Option<crate::model::NodePoolLoggingConfig>,

    /// Parameters that can be configured on Windows nodes.
    pub windows_node_config: std::option::Option<crate::model::WindowsNodeConfig>,

    /// Parameters for using raw-block Local NVMe SSDs.
    pub local_nvme_ssd_block_config: std::option::Option<crate::model::LocalNvmeSsdBlockConfig>,

    /// Parameters for the node ephemeral storage using Local SSDs.
    /// If unspecified, ephemeral storage is backed by the boot disk.
    pub ephemeral_storage_local_ssd_config:
        std::option::Option<crate::model::EphemeralStorageLocalSsdConfig>,

    /// Parameters for node pools to be backed by shared sole tenant node groups.
    pub sole_tenant_config: std::option::Option<crate::model::SoleTenantConfig>,

    /// Parameters for containerd customization.
    pub containerd_config: std::option::Option<crate::model::ContainerdConfig>,

    /// A map of resource manager tag keys and values to be attached to the nodes.
    pub resource_manager_tags: std::option::Option<crate::model::ResourceManagerTags>,

    /// Optional. Reserved for future use.
    pub enable_confidential_storage: bool,

    /// List of secondary boot disks attached to the nodes.
    pub secondary_boot_disks: std::vec::Vec<crate::model::SecondaryBootDisk>,

    /// List of Storage Pools where boot disks are provisioned.
    pub storage_pools: std::vec::Vec<std::string::String>,

    /// Secondary boot disk update strategy.
    pub secondary_boot_disk_update_strategy:
        std::option::Option<crate::model::SecondaryBootDiskUpdateStrategy>,

    /// The configuration for GPU Direct
    pub gpu_direct_config: std::option::Option<crate::model::GPUDirectConfig>,

    /// The maximum duration for the nodes to exist.
    /// If unspecified, the nodes can exist indefinitely.
    pub max_run_duration: std::option::Option<wkt::Duration>,

    /// Specifies which method should be used for encrypting the
    /// Local SSDs attached to the node.
    pub local_ssd_encryption_mode:
        std::option::Option<crate::model::node_config::LocalSsdEncryptionMode>,

    /// Output only. effective_cgroup_mode is the cgroup mode actually used by the
    /// node pool. It is determined by the cgroup mode specified in the
    /// LinuxNodeConfig or the default cgroup mode based on the cluster creation
    /// version.
    pub effective_cgroup_mode: crate::model::node_config::EffectiveCgroupMode,

    /// Flex Start flag for enabling Flex Start VM.
    pub flex_start: std::option::Option<bool>,

    /// The boot disk configuration for the node pool.
    pub boot_disk: std::option::Option<crate::model::BootDisk>,

    /// Consolidation delay defines duration after which the Cluster Autoscaler can
    /// scale down underutilized nodes. If not set, nodes are scaled down by
    /// default behavior, i.e. according to the chosen autoscaling profile.
    pub consolidation_delay: std::option::Option<wkt::Duration>,

    /// Optional. The taint configuration for the node pool.
    pub taint_config: std::option::Option<crate::model::TaintConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [machine_type][crate::model::NodeConfig::machine_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_machine_type("example");
    /// ```
    pub fn set_machine_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.machine_type = v.into();
        self
    }

    /// Sets the value of [disk_size_gb][crate::model::NodeConfig::disk_size_gb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_disk_size_gb(42);
    /// ```
    pub fn set_disk_size_gb<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.disk_size_gb = v.into();
        self
    }

    /// Sets the value of [oauth_scopes][crate::model::NodeConfig::oauth_scopes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_oauth_scopes(["a", "b", "c"]);
    /// ```
    pub fn set_oauth_scopes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.oauth_scopes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service_account][crate::model::NodeConfig::service_account].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_service_account("example");
    /// ```
    pub fn set_service_account<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.service_account = v.into();
        self
    }

    /// Sets the value of [metadata][crate::model::NodeConfig::metadata].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_metadata([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_metadata<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.metadata = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [image_type][crate::model::NodeConfig::image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_image_type("example");
    /// ```
    pub fn set_image_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_type = v.into();
        self
    }

    /// Sets the value of [node_image_config][crate::model::NodeConfig::node_image_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::CustomImageConfig;
    /// let x = NodeConfig::new().set_node_image_config(CustomImageConfig::default()/* use setters */);
    /// ```
    pub fn set_node_image_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CustomImageConfig>,
    {
        self.node_image_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_image_config][crate::model::NodeConfig::node_image_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::CustomImageConfig;
    /// let x = NodeConfig::new().set_or_clear_node_image_config(Some(CustomImageConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_node_image_config(None::<CustomImageConfig>);
    /// ```
    pub fn set_or_clear_node_image_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CustomImageConfig>,
    {
        self.node_image_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [labels][crate::model::NodeConfig::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [local_ssd_count][crate::model::NodeConfig::local_ssd_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_local_ssd_count(42);
    /// ```
    pub fn set_local_ssd_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.local_ssd_count = v.into();
        self
    }

    /// Sets the value of [tags][crate::model::NodeConfig::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_tags(["a", "b", "c"]);
    /// ```
    pub fn set_tags<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.tags = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [preemptible][crate::model::NodeConfig::preemptible].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_preemptible(true);
    /// ```
    pub fn set_preemptible<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.preemptible = v.into();
        self
    }

    /// Sets the value of [accelerators][crate::model::NodeConfig::accelerators].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::AcceleratorConfig;
    /// let x = NodeConfig::new()
    ///     .set_accelerators([
    ///         AcceleratorConfig::default()/* use setters */,
    ///         AcceleratorConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_accelerators<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AcceleratorConfig>,
    {
        use std::iter::Iterator;
        self.accelerators = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [disk_type][crate::model::NodeConfig::disk_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_disk_type("example");
    /// ```
    pub fn set_disk_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.disk_type = v.into();
        self
    }

    /// Sets the value of [min_cpu_platform][crate::model::NodeConfig::min_cpu_platform].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_min_cpu_platform("example");
    /// ```
    pub fn set_min_cpu_platform<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.min_cpu_platform = v.into();
        self
    }

    /// Sets the value of [workload_metadata_config][crate::model::NodeConfig::workload_metadata_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::WorkloadMetadataConfig;
    /// let x = NodeConfig::new().set_workload_metadata_config(WorkloadMetadataConfig::default()/* use setters */);
    /// ```
    pub fn set_workload_metadata_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadMetadataConfig>,
    {
        self.workload_metadata_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [workload_metadata_config][crate::model::NodeConfig::workload_metadata_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::WorkloadMetadataConfig;
    /// let x = NodeConfig::new().set_or_clear_workload_metadata_config(Some(WorkloadMetadataConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_workload_metadata_config(None::<WorkloadMetadataConfig>);
    /// ```
    pub fn set_or_clear_workload_metadata_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadMetadataConfig>,
    {
        self.workload_metadata_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [taints][crate::model::NodeConfig::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::NodeTaint;
    /// let x = NodeConfig::new()
    ///     .set_taints([
    ///         NodeTaint::default()/* use setters */,
    ///         NodeTaint::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_taints<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::NodeTaint>,
    {
        use std::iter::Iterator;
        self.taints = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [sandbox_config][crate::model::NodeConfig::sandbox_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SandboxConfig;
    /// let x = NodeConfig::new().set_sandbox_config(SandboxConfig::default()/* use setters */);
    /// ```
    pub fn set_sandbox_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SandboxConfig>,
    {
        self.sandbox_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [sandbox_config][crate::model::NodeConfig::sandbox_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SandboxConfig;
    /// let x = NodeConfig::new().set_or_clear_sandbox_config(Some(SandboxConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_sandbox_config(None::<SandboxConfig>);
    /// ```
    pub fn set_or_clear_sandbox_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SandboxConfig>,
    {
        self.sandbox_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_group][crate::model::NodeConfig::node_group].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_node_group("example");
    /// ```
    pub fn set_node_group<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_group = v.into();
        self
    }

    /// Sets the value of [reservation_affinity][crate::model::NodeConfig::reservation_affinity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ReservationAffinity;
    /// let x = NodeConfig::new().set_reservation_affinity(ReservationAffinity::default()/* use setters */);
    /// ```
    pub fn set_reservation_affinity<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ReservationAffinity>,
    {
        self.reservation_affinity = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [reservation_affinity][crate::model::NodeConfig::reservation_affinity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ReservationAffinity;
    /// let x = NodeConfig::new().set_or_clear_reservation_affinity(Some(ReservationAffinity::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_reservation_affinity(None::<ReservationAffinity>);
    /// ```
    pub fn set_or_clear_reservation_affinity<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ReservationAffinity>,
    {
        self.reservation_affinity = v.map(|x| x.into());
        self
    }

    /// Sets the value of [shielded_instance_config][crate::model::NodeConfig::shielded_instance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = NodeConfig::new().set_shielded_instance_config(ShieldedInstanceConfig::default()/* use setters */);
    /// ```
    pub fn set_shielded_instance_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedInstanceConfig>,
    {
        self.shielded_instance_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [shielded_instance_config][crate::model::NodeConfig::shielded_instance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = NodeConfig::new().set_or_clear_shielded_instance_config(Some(ShieldedInstanceConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_shielded_instance_config(None::<ShieldedInstanceConfig>);
    /// ```
    pub fn set_or_clear_shielded_instance_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedInstanceConfig>,
    {
        self.shielded_instance_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [linux_node_config][crate::model::NodeConfig::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = NodeConfig::new().set_linux_node_config(LinuxNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_linux_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [linux_node_config][crate::model::NodeConfig::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = NodeConfig::new().set_or_clear_linux_node_config(Some(LinuxNodeConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_linux_node_config(None::<LinuxNodeConfig>);
    /// ```
    pub fn set_or_clear_linux_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [kubelet_config][crate::model::NodeConfig::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeConfig::new().set_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [kubelet_config][crate::model::NodeConfig::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeConfig::new().set_or_clear_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_kubelet_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.kubelet_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [boot_disk_kms_key][crate::model::NodeConfig::boot_disk_kms_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_boot_disk_kms_key("example");
    /// ```
    pub fn set_boot_disk_kms_key<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.boot_disk_kms_key = v.into();
        self
    }

    /// Sets the value of [gcfs_config][crate::model::NodeConfig::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = NodeConfig::new().set_gcfs_config(GcfsConfig::default()/* use setters */);
    /// ```
    pub fn set_gcfs_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcfs_config][crate::model::NodeConfig::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = NodeConfig::new().set_or_clear_gcfs_config(Some(GcfsConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_gcfs_config(None::<GcfsConfig>);
    /// ```
    pub fn set_or_clear_gcfs_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [advanced_machine_features][crate::model::NodeConfig::advanced_machine_features].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = NodeConfig::new().set_advanced_machine_features(AdvancedMachineFeatures::default()/* use setters */);
    /// ```
    pub fn set_advanced_machine_features<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AdvancedMachineFeatures>,
    {
        self.advanced_machine_features = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [advanced_machine_features][crate::model::NodeConfig::advanced_machine_features].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = NodeConfig::new().set_or_clear_advanced_machine_features(Some(AdvancedMachineFeatures::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_advanced_machine_features(None::<AdvancedMachineFeatures>);
    /// ```
    pub fn set_or_clear_advanced_machine_features<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AdvancedMachineFeatures>,
    {
        self.advanced_machine_features = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gvnic][crate::model::NodeConfig::gvnic].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::VirtualNIC;
    /// let x = NodeConfig::new().set_gvnic(VirtualNIC::default()/* use setters */);
    /// ```
    pub fn set_gvnic<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::VirtualNIC>,
    {
        self.gvnic = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gvnic][crate::model::NodeConfig::gvnic].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::VirtualNIC;
    /// let x = NodeConfig::new().set_or_clear_gvnic(Some(VirtualNIC::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_gvnic(None::<VirtualNIC>);
    /// ```
    pub fn set_or_clear_gvnic<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::VirtualNIC>,
    {
        self.gvnic = v.map(|x| x.into());
        self
    }

    /// Sets the value of [spot][crate::model::NodeConfig::spot].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_spot(true);
    /// ```
    pub fn set_spot<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.spot = v.into();
        self
    }

    /// Sets the value of [confidential_nodes][crate::model::NodeConfig::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = NodeConfig::new().set_confidential_nodes(ConfidentialNodes::default()/* use setters */);
    /// ```
    pub fn set_confidential_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [confidential_nodes][crate::model::NodeConfig::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = NodeConfig::new().set_or_clear_confidential_nodes(Some(ConfidentialNodes::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_confidential_nodes(None::<ConfidentialNodes>);
    /// ```
    pub fn set_or_clear_confidential_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [fast_socket][crate::model::NodeConfig::fast_socket].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::FastSocket;
    /// let x = NodeConfig::new().set_fast_socket(FastSocket::default()/* use setters */);
    /// ```
    pub fn set_fast_socket<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::FastSocket>,
    {
        self.fast_socket = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [fast_socket][crate::model::NodeConfig::fast_socket].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::FastSocket;
    /// let x = NodeConfig::new().set_or_clear_fast_socket(Some(FastSocket::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_fast_socket(None::<FastSocket>);
    /// ```
    pub fn set_or_clear_fast_socket<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::FastSocket>,
    {
        self.fast_socket = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_labels][crate::model::NodeConfig::resource_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_resource_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_resource_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.resource_labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [logging_config][crate::model::NodeConfig::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = NodeConfig::new().set_logging_config(NodePoolLoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [logging_config][crate::model::NodeConfig::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = NodeConfig::new().set_or_clear_logging_config(Some(NodePoolLoggingConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_logging_config(None::<NodePoolLoggingConfig>);
    /// ```
    pub fn set_or_clear_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [windows_node_config][crate::model::NodeConfig::windows_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::WindowsNodeConfig;
    /// let x = NodeConfig::new().set_windows_node_config(WindowsNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_windows_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WindowsNodeConfig>,
    {
        self.windows_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [windows_node_config][crate::model::NodeConfig::windows_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::WindowsNodeConfig;
    /// let x = NodeConfig::new().set_or_clear_windows_node_config(Some(WindowsNodeConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_windows_node_config(None::<WindowsNodeConfig>);
    /// ```
    pub fn set_or_clear_windows_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WindowsNodeConfig>,
    {
        self.windows_node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [local_nvme_ssd_block_config][crate::model::NodeConfig::local_nvme_ssd_block_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::LocalNvmeSsdBlockConfig;
    /// let x = NodeConfig::new().set_local_nvme_ssd_block_config(LocalNvmeSsdBlockConfig::default()/* use setters */);
    /// ```
    pub fn set_local_nvme_ssd_block_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LocalNvmeSsdBlockConfig>,
    {
        self.local_nvme_ssd_block_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [local_nvme_ssd_block_config][crate::model::NodeConfig::local_nvme_ssd_block_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::LocalNvmeSsdBlockConfig;
    /// let x = NodeConfig::new().set_or_clear_local_nvme_ssd_block_config(Some(LocalNvmeSsdBlockConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_local_nvme_ssd_block_config(None::<LocalNvmeSsdBlockConfig>);
    /// ```
    pub fn set_or_clear_local_nvme_ssd_block_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LocalNvmeSsdBlockConfig>,
    {
        self.local_nvme_ssd_block_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ephemeral_storage_local_ssd_config][crate::model::NodeConfig::ephemeral_storage_local_ssd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::EphemeralStorageLocalSsdConfig;
    /// let x = NodeConfig::new().set_ephemeral_storage_local_ssd_config(EphemeralStorageLocalSsdConfig::default()/* use setters */);
    /// ```
    pub fn set_ephemeral_storage_local_ssd_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::EphemeralStorageLocalSsdConfig>,
    {
        self.ephemeral_storage_local_ssd_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ephemeral_storage_local_ssd_config][crate::model::NodeConfig::ephemeral_storage_local_ssd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::EphemeralStorageLocalSsdConfig;
    /// let x = NodeConfig::new().set_or_clear_ephemeral_storage_local_ssd_config(Some(EphemeralStorageLocalSsdConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_ephemeral_storage_local_ssd_config(None::<EphemeralStorageLocalSsdConfig>);
    /// ```
    pub fn set_or_clear_ephemeral_storage_local_ssd_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::EphemeralStorageLocalSsdConfig>,
    {
        self.ephemeral_storage_local_ssd_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [sole_tenant_config][crate::model::NodeConfig::sole_tenant_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SoleTenantConfig;
    /// let x = NodeConfig::new().set_sole_tenant_config(SoleTenantConfig::default()/* use setters */);
    /// ```
    pub fn set_sole_tenant_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SoleTenantConfig>,
    {
        self.sole_tenant_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [sole_tenant_config][crate::model::NodeConfig::sole_tenant_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SoleTenantConfig;
    /// let x = NodeConfig::new().set_or_clear_sole_tenant_config(Some(SoleTenantConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_sole_tenant_config(None::<SoleTenantConfig>);
    /// ```
    pub fn set_or_clear_sole_tenant_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SoleTenantConfig>,
    {
        self.sole_tenant_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [containerd_config][crate::model::NodeConfig::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = NodeConfig::new().set_containerd_config(ContainerdConfig::default()/* use setters */);
    /// ```
    pub fn set_containerd_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [containerd_config][crate::model::NodeConfig::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = NodeConfig::new().set_or_clear_containerd_config(Some(ContainerdConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_containerd_config(None::<ContainerdConfig>);
    /// ```
    pub fn set_or_clear_containerd_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_manager_tags][crate::model::NodeConfig::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = NodeConfig::new().set_resource_manager_tags(ResourceManagerTags::default()/* use setters */);
    /// ```
    pub fn set_resource_manager_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [resource_manager_tags][crate::model::NodeConfig::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = NodeConfig::new().set_or_clear_resource_manager_tags(Some(ResourceManagerTags::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_resource_manager_tags(None::<ResourceManagerTags>);
    /// ```
    pub fn set_or_clear_resource_manager_tags<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_confidential_storage][crate::model::NodeConfig::enable_confidential_storage].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_enable_confidential_storage(true);
    /// ```
    pub fn set_enable_confidential_storage<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_confidential_storage = v.into();
        self
    }

    /// Sets the value of [secondary_boot_disks][crate::model::NodeConfig::secondary_boot_disks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SecondaryBootDisk;
    /// let x = NodeConfig::new()
    ///     .set_secondary_boot_disks([
    ///         SecondaryBootDisk::default()/* use setters */,
    ///         SecondaryBootDisk::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_secondary_boot_disks<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::SecondaryBootDisk>,
    {
        use std::iter::Iterator;
        self.secondary_boot_disks = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [storage_pools][crate::model::NodeConfig::storage_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_storage_pools(["a", "b", "c"]);
    /// ```
    pub fn set_storage_pools<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.storage_pools = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [secondary_boot_disk_update_strategy][crate::model::NodeConfig::secondary_boot_disk_update_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SecondaryBootDiskUpdateStrategy;
    /// let x = NodeConfig::new().set_secondary_boot_disk_update_strategy(SecondaryBootDiskUpdateStrategy::default()/* use setters */);
    /// ```
    pub fn set_secondary_boot_disk_update_strategy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecondaryBootDiskUpdateStrategy>,
    {
        self.secondary_boot_disk_update_strategy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [secondary_boot_disk_update_strategy][crate::model::NodeConfig::secondary_boot_disk_update_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::SecondaryBootDiskUpdateStrategy;
    /// let x = NodeConfig::new().set_or_clear_secondary_boot_disk_update_strategy(Some(SecondaryBootDiskUpdateStrategy::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_secondary_boot_disk_update_strategy(None::<SecondaryBootDiskUpdateStrategy>);
    /// ```
    pub fn set_or_clear_secondary_boot_disk_update_strategy<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::SecondaryBootDiskUpdateStrategy>,
    {
        self.secondary_boot_disk_update_strategy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gpu_direct_config][crate::model::NodeConfig::gpu_direct_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::GPUDirectConfig;
    /// let x = NodeConfig::new().set_gpu_direct_config(GPUDirectConfig::default()/* use setters */);
    /// ```
    pub fn set_gpu_direct_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GPUDirectConfig>,
    {
        self.gpu_direct_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_direct_config][crate::model::NodeConfig::gpu_direct_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::GPUDirectConfig;
    /// let x = NodeConfig::new().set_or_clear_gpu_direct_config(Some(GPUDirectConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_gpu_direct_config(None::<GPUDirectConfig>);
    /// ```
    pub fn set_or_clear_gpu_direct_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GPUDirectConfig>,
    {
        self.gpu_direct_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [max_run_duration][crate::model::NodeConfig::max_run_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use wkt::Duration;
    /// let x = NodeConfig::new().set_max_run_duration(Duration::default()/* use setters */);
    /// ```
    pub fn set_max_run_duration<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_run_duration = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [max_run_duration][crate::model::NodeConfig::max_run_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use wkt::Duration;
    /// let x = NodeConfig::new().set_or_clear_max_run_duration(Some(Duration::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_max_run_duration(None::<Duration>);
    /// ```
    pub fn set_or_clear_max_run_duration<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_run_duration = v.map(|x| x.into());
        self
    }

    /// Sets the value of [local_ssd_encryption_mode][crate::model::NodeConfig::local_ssd_encryption_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::node_config::LocalSsdEncryptionMode;
    /// let x0 = NodeConfig::new().set_local_ssd_encryption_mode(LocalSsdEncryptionMode::StandardEncryption);
    /// let x1 = NodeConfig::new().set_local_ssd_encryption_mode(LocalSsdEncryptionMode::EphemeralKeyEncryption);
    /// ```
    pub fn set_local_ssd_encryption_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_config::LocalSsdEncryptionMode>,
    {
        self.local_ssd_encryption_mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [local_ssd_encryption_mode][crate::model::NodeConfig::local_ssd_encryption_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::node_config::LocalSsdEncryptionMode;
    /// let x0 = NodeConfig::new().set_or_clear_local_ssd_encryption_mode(Some(LocalSsdEncryptionMode::StandardEncryption));
    /// let x1 = NodeConfig::new().set_or_clear_local_ssd_encryption_mode(Some(LocalSsdEncryptionMode::EphemeralKeyEncryption));
    /// let x_none = NodeConfig::new().set_or_clear_local_ssd_encryption_mode(None::<LocalSsdEncryptionMode>);
    /// ```
    pub fn set_or_clear_local_ssd_encryption_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_config::LocalSsdEncryptionMode>,
    {
        self.local_ssd_encryption_mode = v.map(|x| x.into());
        self
    }

    /// Sets the value of [effective_cgroup_mode][crate::model::NodeConfig::effective_cgroup_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::node_config::EffectiveCgroupMode;
    /// let x0 = NodeConfig::new().set_effective_cgroup_mode(EffectiveCgroupMode::V1);
    /// let x1 = NodeConfig::new().set_effective_cgroup_mode(EffectiveCgroupMode::V2);
    /// ```
    pub fn set_effective_cgroup_mode<
        T: std::convert::Into<crate::model::node_config::EffectiveCgroupMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.effective_cgroup_mode = v.into();
        self
    }

    /// Sets the value of [flex_start][crate::model::NodeConfig::flex_start].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_flex_start(true);
    /// ```
    pub fn set_flex_start<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.flex_start = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [flex_start][crate::model::NodeConfig::flex_start].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodeConfig::new().set_or_clear_flex_start(Some(false));
    /// let x = NodeConfig::new().set_or_clear_flex_start(None::<bool>);
    /// ```
    pub fn set_or_clear_flex_start<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.flex_start = v.map(|x| x.into());
        self
    }

    /// Sets the value of [boot_disk][crate::model::NodeConfig::boot_disk].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::BootDisk;
    /// let x = NodeConfig::new().set_boot_disk(BootDisk::default()/* use setters */);
    /// ```
    pub fn set_boot_disk<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BootDisk>,
    {
        self.boot_disk = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [boot_disk][crate::model::NodeConfig::boot_disk].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::BootDisk;
    /// let x = NodeConfig::new().set_or_clear_boot_disk(Some(BootDisk::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_boot_disk(None::<BootDisk>);
    /// ```
    pub fn set_or_clear_boot_disk<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BootDisk>,
    {
        self.boot_disk = v.map(|x| x.into());
        self
    }

    /// Sets the value of [consolidation_delay][crate::model::NodeConfig::consolidation_delay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use wkt::Duration;
    /// let x = NodeConfig::new().set_consolidation_delay(Duration::default()/* use setters */);
    /// ```
    pub fn set_consolidation_delay<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.consolidation_delay = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [consolidation_delay][crate::model::NodeConfig::consolidation_delay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use wkt::Duration;
    /// let x = NodeConfig::new().set_or_clear_consolidation_delay(Some(Duration::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_consolidation_delay(None::<Duration>);
    /// ```
    pub fn set_or_clear_consolidation_delay<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.consolidation_delay = v.map(|x| x.into());
        self
    }

    /// Sets the value of [taint_config][crate::model::NodeConfig::taint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::TaintConfig;
    /// let x = NodeConfig::new().set_taint_config(TaintConfig::default()/* use setters */);
    /// ```
    pub fn set_taint_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TaintConfig>,
    {
        self.taint_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [taint_config][crate::model::NodeConfig::taint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfig;
    /// use google_cloud_container_v1::model::TaintConfig;
    /// let x = NodeConfig::new().set_or_clear_taint_config(Some(TaintConfig::default()/* use setters */));
    /// let x = NodeConfig::new().set_or_clear_taint_config(None::<TaintConfig>);
    /// ```
    pub fn set_or_clear_taint_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TaintConfig>,
    {
        self.taint_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeConfig"
    }
}

/// Defines additional types related to [NodeConfig].
pub mod node_config {
    #[allow(unused_imports)]
    use super::*;

    /// LocalSsdEncryptionMode specifies the method used for encrypting the Local
    /// SSDs attached to the node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LocalSsdEncryptionMode {
        /// The given node will be encrypted using keys managed by Google
        /// infrastructure and the keys will be deleted when the node is
        /// deleted.
        Unspecified,
        /// The given node will be encrypted using keys managed by Google
        /// infrastructure and the keys will be deleted when the node is
        /// deleted.
        StandardEncryption,
        /// The given node will opt-in for using ephemeral key for
        /// encryption of Local SSDs.
        /// The Local SSDs will not be able to recover data in case of node
        /// crash.
        EphemeralKeyEncryption,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [LocalSsdEncryptionMode::value] or
        /// [LocalSsdEncryptionMode::name].
        UnknownValue(local_ssd_encryption_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod local_ssd_encryption_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl LocalSsdEncryptionMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::StandardEncryption => std::option::Option::Some(1),
                Self::EphemeralKeyEncryption => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("LOCAL_SSD_ENCRYPTION_MODE_UNSPECIFIED")
                }
                Self::StandardEncryption => std::option::Option::Some("STANDARD_ENCRYPTION"),
                Self::EphemeralKeyEncryption => {
                    std::option::Option::Some("EPHEMERAL_KEY_ENCRYPTION")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for LocalSsdEncryptionMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for LocalSsdEncryptionMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for LocalSsdEncryptionMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::StandardEncryption,
                2 => Self::EphemeralKeyEncryption,
                _ => Self::UnknownValue(local_ssd_encryption_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for LocalSsdEncryptionMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LOCAL_SSD_ENCRYPTION_MODE_UNSPECIFIED" => Self::Unspecified,
                "STANDARD_ENCRYPTION" => Self::StandardEncryption,
                "EPHEMERAL_KEY_ENCRYPTION" => Self::EphemeralKeyEncryption,
                _ => Self::UnknownValue(local_ssd_encryption_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for LocalSsdEncryptionMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::StandardEncryption => serializer.serialize_i32(1),
                Self::EphemeralKeyEncryption => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for LocalSsdEncryptionMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<LocalSsdEncryptionMode>::new(
                ".google.container.v1.NodeConfig.LocalSsdEncryptionMode",
            ))
        }
    }

    /// Possible effective cgroup modes for the node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EffectiveCgroupMode {
        /// EFFECTIVE_CGROUP_MODE_UNSPECIFIED means the cgroup configuration for the
        /// node pool is unspecified, i.e. the node pool is a Windows node pool.
        Unspecified,
        /// CGROUP_MODE_V1 means the node pool is configured to use cgroupv1 for the
        /// cgroup configuration.
        V1,
        /// CGROUP_MODE_V2 means the node pool is configured to use cgroupv2 for the
        /// cgroup configuration.
        V2,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EffectiveCgroupMode::value] or
        /// [EffectiveCgroupMode::name].
        UnknownValue(effective_cgroup_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod effective_cgroup_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EffectiveCgroupMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::V1 => std::option::Option::Some(1),
                Self::V2 => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EFFECTIVE_CGROUP_MODE_UNSPECIFIED"),
                Self::V1 => std::option::Option::Some("EFFECTIVE_CGROUP_MODE_V1"),
                Self::V2 => std::option::Option::Some("EFFECTIVE_CGROUP_MODE_V2"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EffectiveCgroupMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EffectiveCgroupMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EffectiveCgroupMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::V1,
                2 => Self::V2,
                _ => Self::UnknownValue(effective_cgroup_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EffectiveCgroupMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EFFECTIVE_CGROUP_MODE_UNSPECIFIED" => Self::Unspecified,
                "EFFECTIVE_CGROUP_MODE_V1" => Self::V1,
                "EFFECTIVE_CGROUP_MODE_V2" => Self::V2,
                _ => Self::UnknownValue(effective_cgroup_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EffectiveCgroupMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::V1 => serializer.serialize_i32(1),
                Self::V2 => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EffectiveCgroupMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EffectiveCgroupMode>::new(
                ".google.container.v1.NodeConfig.EffectiveCgroupMode",
            ))
        }
    }
}

/// TaintConfig contains the configuration for the taints of the node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TaintConfig {
    /// Optional. Controls architecture tainting behavior.
    pub architecture_taint_behavior:
        std::option::Option<crate::model::taint_config::ArchitectureTaintBehavior>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TaintConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [architecture_taint_behavior][crate::model::TaintConfig::architecture_taint_behavior].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TaintConfig;
    /// use google_cloud_container_v1::model::taint_config::ArchitectureTaintBehavior;
    /// let x0 = TaintConfig::new().set_architecture_taint_behavior(ArchitectureTaintBehavior::None);
    /// let x1 = TaintConfig::new().set_architecture_taint_behavior(ArchitectureTaintBehavior::Arm);
    /// ```
    pub fn set_architecture_taint_behavior<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::taint_config::ArchitectureTaintBehavior>,
    {
        self.architecture_taint_behavior = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [architecture_taint_behavior][crate::model::TaintConfig::architecture_taint_behavior].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TaintConfig;
    /// use google_cloud_container_v1::model::taint_config::ArchitectureTaintBehavior;
    /// let x0 = TaintConfig::new().set_or_clear_architecture_taint_behavior(Some(ArchitectureTaintBehavior::None));
    /// let x1 = TaintConfig::new().set_or_clear_architecture_taint_behavior(Some(ArchitectureTaintBehavior::Arm));
    /// let x_none = TaintConfig::new().set_or_clear_architecture_taint_behavior(None::<ArchitectureTaintBehavior>);
    /// ```
    pub fn set_or_clear_architecture_taint_behavior<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::taint_config::ArchitectureTaintBehavior>,
    {
        self.architecture_taint_behavior = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for TaintConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.TaintConfig"
    }
}

/// Defines additional types related to [TaintConfig].
pub mod taint_config {
    #[allow(unused_imports)]
    use super::*;

    /// Controls architecture tainting behavior for a node pool.
    /// New values may be added in the future.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ArchitectureTaintBehavior {
        /// Specifies that the behavior is unspecified, defaults to ARM.
        Unspecified,
        /// Disables default architecture taints on the node pool.
        None,
        /// Taints all the nodes in the node pool with the default ARM taint.
        Arm,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ArchitectureTaintBehavior::value] or
        /// [ArchitectureTaintBehavior::name].
        UnknownValue(architecture_taint_behavior::UnknownValue),
    }

    #[doc(hidden)]
    pub mod architecture_taint_behavior {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ArchitectureTaintBehavior {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::None => std::option::Option::Some(1),
                Self::Arm => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("ARCHITECTURE_TAINT_BEHAVIOR_UNSPECIFIED")
                }
                Self::None => std::option::Option::Some("NONE"),
                Self::Arm => std::option::Option::Some("ARM"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ArchitectureTaintBehavior {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ArchitectureTaintBehavior {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ArchitectureTaintBehavior {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::None,
                2 => Self::Arm,
                _ => Self::UnknownValue(architecture_taint_behavior::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ArchitectureTaintBehavior {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "ARCHITECTURE_TAINT_BEHAVIOR_UNSPECIFIED" => Self::Unspecified,
                "NONE" => Self::None,
                "ARM" => Self::Arm,
                _ => Self::UnknownValue(architecture_taint_behavior::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ArchitectureTaintBehavior {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::None => serializer.serialize_i32(1),
                Self::Arm => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ArchitectureTaintBehavior {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<ArchitectureTaintBehavior>::new(
                    ".google.container.v1.TaintConfig.ArchitectureTaintBehavior",
                ),
            )
        }
    }
}

/// Specifies options for controlling advanced machine features.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdvancedMachineFeatures {
    /// The number of threads per physical core. To disable simultaneous
    /// multithreading (SMT) set this to 1. If unset, the maximum number of threads
    /// supported per core by the underlying processor is assumed.
    pub threads_per_core: std::option::Option<i64>,

    /// Whether or not to enable nested virtualization (defaults to false).
    pub enable_nested_virtualization: std::option::Option<bool>,

    /// Type of Performance Monitoring Unit (PMU) requested on node pool instances.
    /// If unset, PMU will not be available to the node.
    pub performance_monitoring_unit:
        std::option::Option<crate::model::advanced_machine_features::PerformanceMonitoringUnit>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdvancedMachineFeatures {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [threads_per_core][crate::model::AdvancedMachineFeatures::threads_per_core].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = AdvancedMachineFeatures::new().set_threads_per_core(42);
    /// ```
    pub fn set_threads_per_core<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.threads_per_core = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [threads_per_core][crate::model::AdvancedMachineFeatures::threads_per_core].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = AdvancedMachineFeatures::new().set_or_clear_threads_per_core(Some(42));
    /// let x = AdvancedMachineFeatures::new().set_or_clear_threads_per_core(None::<i32>);
    /// ```
    pub fn set_or_clear_threads_per_core<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i64>,
    {
        self.threads_per_core = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_nested_virtualization][crate::model::AdvancedMachineFeatures::enable_nested_virtualization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = AdvancedMachineFeatures::new().set_enable_nested_virtualization(true);
    /// ```
    pub fn set_enable_nested_virtualization<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_nested_virtualization = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_nested_virtualization][crate::model::AdvancedMachineFeatures::enable_nested_virtualization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// let x = AdvancedMachineFeatures::new().set_or_clear_enable_nested_virtualization(Some(false));
    /// let x = AdvancedMachineFeatures::new().set_or_clear_enable_nested_virtualization(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_nested_virtualization<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_nested_virtualization = v.map(|x| x.into());
        self
    }

    /// Sets the value of [performance_monitoring_unit][crate::model::AdvancedMachineFeatures::performance_monitoring_unit].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// use google_cloud_container_v1::model::advanced_machine_features::PerformanceMonitoringUnit;
    /// let x0 = AdvancedMachineFeatures::new().set_performance_monitoring_unit(PerformanceMonitoringUnit::Architectural);
    /// let x1 = AdvancedMachineFeatures::new().set_performance_monitoring_unit(PerformanceMonitoringUnit::Standard);
    /// let x2 = AdvancedMachineFeatures::new().set_performance_monitoring_unit(PerformanceMonitoringUnit::Enhanced);
    /// ```
    pub fn set_performance_monitoring_unit<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::advanced_machine_features::PerformanceMonitoringUnit>,
    {
        self.performance_monitoring_unit = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [performance_monitoring_unit][crate::model::AdvancedMachineFeatures::performance_monitoring_unit].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedMachineFeatures;
    /// use google_cloud_container_v1::model::advanced_machine_features::PerformanceMonitoringUnit;
    /// let x0 = AdvancedMachineFeatures::new().set_or_clear_performance_monitoring_unit(Some(PerformanceMonitoringUnit::Architectural));
    /// let x1 = AdvancedMachineFeatures::new().set_or_clear_performance_monitoring_unit(Some(PerformanceMonitoringUnit::Standard));
    /// let x2 = AdvancedMachineFeatures::new().set_or_clear_performance_monitoring_unit(Some(PerformanceMonitoringUnit::Enhanced));
    /// let x_none = AdvancedMachineFeatures::new().set_or_clear_performance_monitoring_unit(None::<PerformanceMonitoringUnit>);
    /// ```
    pub fn set_or_clear_performance_monitoring_unit<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::advanced_machine_features::PerformanceMonitoringUnit>,
    {
        self.performance_monitoring_unit = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AdvancedMachineFeatures {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdvancedMachineFeatures"
    }
}

/// Defines additional types related to [AdvancedMachineFeatures].
pub mod advanced_machine_features {
    #[allow(unused_imports)]
    use super::*;

    /// Level of PMU access.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PerformanceMonitoringUnit {
        /// PMU not enabled.
        Unspecified,
        /// Architecturally defined non-LLC events.
        Architectural,
        /// Most documented core/L2 events.
        Standard,
        /// Most documented core/L2 and LLC events.
        Enhanced,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [PerformanceMonitoringUnit::value] or
        /// [PerformanceMonitoringUnit::name].
        UnknownValue(performance_monitoring_unit::UnknownValue),
    }

    #[doc(hidden)]
    pub mod performance_monitoring_unit {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl PerformanceMonitoringUnit {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Architectural => std::option::Option::Some(1),
                Self::Standard => std::option::Option::Some(2),
                Self::Enhanced => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("PERFORMANCE_MONITORING_UNIT_UNSPECIFIED")
                }
                Self::Architectural => std::option::Option::Some("ARCHITECTURAL"),
                Self::Standard => std::option::Option::Some("STANDARD"),
                Self::Enhanced => std::option::Option::Some("ENHANCED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for PerformanceMonitoringUnit {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for PerformanceMonitoringUnit {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for PerformanceMonitoringUnit {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Architectural,
                2 => Self::Standard,
                3 => Self::Enhanced,
                _ => Self::UnknownValue(performance_monitoring_unit::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for PerformanceMonitoringUnit {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PERFORMANCE_MONITORING_UNIT_UNSPECIFIED" => Self::Unspecified,
                "ARCHITECTURAL" => Self::Architectural,
                "STANDARD" => Self::Standard,
                "ENHANCED" => Self::Enhanced,
                _ => Self::UnknownValue(performance_monitoring_unit::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for PerformanceMonitoringUnit {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Architectural => serializer.serialize_i32(1),
                Self::Standard => serializer.serialize_i32(2),
                Self::Enhanced => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for PerformanceMonitoringUnit {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<PerformanceMonitoringUnit>::new(
                    ".google.container.v1.AdvancedMachineFeatures.PerformanceMonitoringUnit",
                ),
            )
        }
    }
}

/// Parameters for node pool-level network config.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeNetworkConfig {
    /// Input only. Whether to create a new range for pod IPs in this node pool.
    /// Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they
    /// are not specified.
    ///
    /// If neither `create_pod_range` or `pod_range` are specified, the
    /// cluster-level default (`ip_allocation_policy.cluster_ipv4_cidr_block`) is
    /// used.
    ///
    /// Only applicable if `ip_allocation_policy.use_ip_aliases` is true.
    ///
    /// This field cannot be changed after the node pool has been created.
    pub create_pod_range: bool,

    /// The ID of the secondary range for pod IPs.
    /// If `create_pod_range` is true, this ID is used for the new range.
    /// If `create_pod_range` is false, uses an existing secondary range with this
    /// ID.
    ///
    /// Only applicable if `ip_allocation_policy.use_ip_aliases` is true.
    ///
    /// This field cannot be changed after the node pool has been created.
    pub pod_range: std::string::String,

    /// The IP address range for pod IPs in this node pool.
    ///
    /// Only applicable if `create_pod_range` is true.
    ///
    /// Set to blank to have a range chosen with the default size.
    ///
    /// Set to /netmask (e.g. `/14`) to have a range chosen with a specific
    /// netmask.
    ///
    /// Set to a
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`) to pick a specific range to use.
    ///
    /// Only applicable if `ip_allocation_policy.use_ip_aliases` is true.
    ///
    /// This field cannot be changed after the node pool has been created.
    pub pod_ipv4_cidr_block: std::string::String,

    /// Whether nodes have internal IP addresses only.
    /// If enable_private_nodes is not specified, then the value is derived from
    /// [Cluster.NetworkConfig.default_enable_private_nodes][]
    pub enable_private_nodes: std::option::Option<bool>,

    /// Network bandwidth tier configuration.
    pub network_performance_config:
        std::option::Option<crate::model::node_network_config::NetworkPerformanceConfig>,

    /// [PRIVATE FIELD]
    /// Pod CIDR size overprovisioning config for the node pool.
    ///
    /// Pod CIDR size per node depends on max_pods_per_node. By default, the value
    /// of max_pods_per_node is rounded off to next power of 2 and we then double
    /// that to get the size of pod CIDR block per node.
    /// Example: max_pods_per_node of 30 would result in 64 IPs (/26).
    ///
    /// This config can disable the doubling of IPs (we still round off to next
    /// power of 2)
    /// Example: max_pods_per_node of 30 will result in 32 IPs (/27) when
    /// overprovisioning is disabled.
    pub pod_cidr_overprovision_config:
        std::option::Option<crate::model::PodCIDROverprovisionConfig>,

    /// We specify the additional node networks for this node pool using this list.
    /// Each node network corresponds to an additional interface
    pub additional_node_network_configs: std::vec::Vec<crate::model::AdditionalNodeNetworkConfig>,

    /// We specify the additional pod networks for this node pool using this list.
    /// Each pod network corresponds to an additional alias IP range for the node
    pub additional_pod_network_configs: std::vec::Vec<crate::model::AdditionalPodNetworkConfig>,

    /// Output only. The utilization of the IPv4 range for the pod.
    /// The ratio is Usage/[Total number of IPs in the secondary range],
    /// Usage=numNodes*numZones*podIPsPerNode.
    pub pod_ipv4_range_utilization: f64,

    /// Optional. The subnetwork name/path for the node pool.
    /// Format: projects/{project}/regions/{region}/subnetworks/{subnetwork}
    /// If the cluster is associated with multiple subnetworks, the subnetwork can
    /// be either:
    ///
    /// - A user supplied subnetwork name during node pool creation (e.g.,
    ///   `my-subnet`). The name must be between 1 and 63 characters long, start
    ///   with a letter, contain only letters, numbers, and hyphens, and end with a
    ///   letter or a number.
    /// - A full subnetwork path during node pool creation, such as
    ///   `projects/gke-project/regions/us-central1/subnetworks/my-subnet`
    /// - A subnetwork path picked based on the IP utilization during node pool
    ///   creation and is immutable.
    pub subnetwork: std::string::String,

    /// Output only. The network tier configuration for the node pool inherits from
    /// the cluster-level configuration and remains immutable throughout the node
    /// pool's lifecycle, including during upgrades.
    pub network_tier_config: std::option::Option<crate::model::NetworkTierConfig>,

    /// Immutable. The accelerator network profile for the node pool. For now the
    /// only valid value is "auto". If specified, the network configuration of the
    /// nodes in this node pool will be managed by this profile for the supported
    /// machine types, zone, etc.
    pub accelerator_network_profile: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeNetworkConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_pod_range][crate::model::NodeNetworkConfig::create_pod_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_create_pod_range(true);
    /// ```
    pub fn set_create_pod_range<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.create_pod_range = v.into();
        self
    }

    /// Sets the value of [pod_range][crate::model::NodeNetworkConfig::pod_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_pod_range("example");
    /// ```
    pub fn set_pod_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.pod_range = v.into();
        self
    }

    /// Sets the value of [pod_ipv4_cidr_block][crate::model::NodeNetworkConfig::pod_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_pod_ipv4_cidr_block("example");
    /// ```
    pub fn set_pod_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.pod_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [enable_private_nodes][crate::model::NodeNetworkConfig::enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_enable_private_nodes(true);
    /// ```
    pub fn set_enable_private_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_private_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_private_nodes][crate::model::NodeNetworkConfig::enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_or_clear_enable_private_nodes(Some(false));
    /// let x = NodeNetworkConfig::new().set_or_clear_enable_private_nodes(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_private_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_private_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [network_performance_config][crate::model::NodeNetworkConfig::network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::node_network_config::NetworkPerformanceConfig;
    /// let x = NodeNetworkConfig::new().set_network_performance_config(NetworkPerformanceConfig::default()/* use setters */);
    /// ```
    pub fn set_network_performance_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_network_config::NetworkPerformanceConfig>,
    {
        self.network_performance_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_performance_config][crate::model::NodeNetworkConfig::network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::node_network_config::NetworkPerformanceConfig;
    /// let x = NodeNetworkConfig::new().set_or_clear_network_performance_config(Some(NetworkPerformanceConfig::default()/* use setters */));
    /// let x = NodeNetworkConfig::new().set_or_clear_network_performance_config(None::<NetworkPerformanceConfig>);
    /// ```
    pub fn set_or_clear_network_performance_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_network_config::NetworkPerformanceConfig>,
    {
        self.network_performance_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [pod_cidr_overprovision_config][crate::model::NodeNetworkConfig::pod_cidr_overprovision_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::PodCIDROverprovisionConfig;
    /// let x = NodeNetworkConfig::new().set_pod_cidr_overprovision_config(PodCIDROverprovisionConfig::default()/* use setters */);
    /// ```
    pub fn set_pod_cidr_overprovision_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PodCIDROverprovisionConfig>,
    {
        self.pod_cidr_overprovision_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pod_cidr_overprovision_config][crate::model::NodeNetworkConfig::pod_cidr_overprovision_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::PodCIDROverprovisionConfig;
    /// let x = NodeNetworkConfig::new().set_or_clear_pod_cidr_overprovision_config(Some(PodCIDROverprovisionConfig::default()/* use setters */));
    /// let x = NodeNetworkConfig::new().set_or_clear_pod_cidr_overprovision_config(None::<PodCIDROverprovisionConfig>);
    /// ```
    pub fn set_or_clear_pod_cidr_overprovision_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::PodCIDROverprovisionConfig>,
    {
        self.pod_cidr_overprovision_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [additional_node_network_configs][crate::model::NodeNetworkConfig::additional_node_network_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::AdditionalNodeNetworkConfig;
    /// let x = NodeNetworkConfig::new()
    ///     .set_additional_node_network_configs([
    ///         AdditionalNodeNetworkConfig::default()/* use setters */,
    ///         AdditionalNodeNetworkConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_additional_node_network_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AdditionalNodeNetworkConfig>,
    {
        use std::iter::Iterator;
        self.additional_node_network_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [additional_pod_network_configs][crate::model::NodeNetworkConfig::additional_pod_network_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::AdditionalPodNetworkConfig;
    /// let x = NodeNetworkConfig::new()
    ///     .set_additional_pod_network_configs([
    ///         AdditionalPodNetworkConfig::default()/* use setters */,
    ///         AdditionalPodNetworkConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_additional_pod_network_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AdditionalPodNetworkConfig>,
    {
        use std::iter::Iterator;
        self.additional_pod_network_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [pod_ipv4_range_utilization][crate::model::NodeNetworkConfig::pod_ipv4_range_utilization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_pod_ipv4_range_utilization(42.0);
    /// ```
    pub fn set_pod_ipv4_range_utilization<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.pod_ipv4_range_utilization = v.into();
        self
    }

    /// Sets the value of [subnetwork][crate::model::NodeNetworkConfig::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [network_tier_config][crate::model::NodeNetworkConfig::network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = NodeNetworkConfig::new().set_network_tier_config(NetworkTierConfig::default()/* use setters */);
    /// ```
    pub fn set_network_tier_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.network_tier_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_tier_config][crate::model::NodeNetworkConfig::network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = NodeNetworkConfig::new().set_or_clear_network_tier_config(Some(NetworkTierConfig::default()/* use setters */));
    /// let x = NodeNetworkConfig::new().set_or_clear_network_tier_config(None::<NetworkTierConfig>);
    /// ```
    pub fn set_or_clear_network_tier_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.network_tier_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [accelerator_network_profile][crate::model::NodeNetworkConfig::accelerator_network_profile].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodeNetworkConfig::new().set_accelerator_network_profile("example");
    /// ```
    pub fn set_accelerator_network_profile<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.accelerator_network_profile = v.into();
        self
    }
}

impl wkt::message::Message for NodeNetworkConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeNetworkConfig"
    }
}

/// Defines additional types related to [NodeNetworkConfig].
pub mod node_network_config {
    #[allow(unused_imports)]
    use super::*;

    /// Configuration of all network bandwidth tiers
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NetworkPerformanceConfig {
        /// Specifies the total network bandwidth tier for the NodePool.
        pub total_egress_bandwidth_tier: std::option::Option<
            crate::model::node_network_config::network_performance_config::Tier,
        >,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NetworkPerformanceConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [total_egress_bandwidth_tier][crate::model::node_network_config::NetworkPerformanceConfig::total_egress_bandwidth_tier].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_network_config::NetworkPerformanceConfig;
        /// use google_cloud_container_v1::model::node_network_config::network_performance_config::Tier;
        /// let x0 = NetworkPerformanceConfig::new().set_total_egress_bandwidth_tier(Tier::Tier1);
        /// ```
        pub fn set_total_egress_bandwidth_tier<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<
                    crate::model::node_network_config::network_performance_config::Tier,
                >,
        {
            self.total_egress_bandwidth_tier = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [total_egress_bandwidth_tier][crate::model::node_network_config::NetworkPerformanceConfig::total_egress_bandwidth_tier].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_network_config::NetworkPerformanceConfig;
        /// use google_cloud_container_v1::model::node_network_config::network_performance_config::Tier;
        /// let x0 = NetworkPerformanceConfig::new().set_or_clear_total_egress_bandwidth_tier(Some(Tier::Tier1));
        /// let x_none = NetworkPerformanceConfig::new().set_or_clear_total_egress_bandwidth_tier(None::<Tier>);
        /// ```
        pub fn set_or_clear_total_egress_bandwidth_tier<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<
                    crate::model::node_network_config::network_performance_config::Tier,
                >,
        {
            self.total_egress_bandwidth_tier = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for NetworkPerformanceConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodeNetworkConfig.NetworkPerformanceConfig"
        }
    }

    /// Defines additional types related to [NetworkPerformanceConfig].
    pub mod network_performance_config {
        #[allow(unused_imports)]
        use super::*;

        /// Node network tier
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Tier {
            /// Default value
            Unspecified,
            /// Higher bandwidth, actual values based on VM size.
            Tier1,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Tier::value] or
            /// [Tier::name].
            UnknownValue(tier::UnknownValue),
        }

        #[doc(hidden)]
        pub mod tier {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Tier {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Tier1 => std::option::Option::Some(1),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("TIER_UNSPECIFIED"),
                    Self::Tier1 => std::option::Option::Some("TIER_1"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Tier {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Tier {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Tier {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Tier1,
                    _ => Self::UnknownValue(tier::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Tier {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "TIER_UNSPECIFIED" => Self::Unspecified,
                    "TIER_1" => Self::Tier1,
                    _ => Self::UnknownValue(tier::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Tier {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Tier1 => serializer.serialize_i32(1),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Tier {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Tier>::new(
                    ".google.container.v1.NodeNetworkConfig.NetworkPerformanceConfig.Tier",
                ))
            }
        }
    }
}

/// AdditionalNodeNetworkConfig is the configuration for additional node networks
/// within the NodeNetworkConfig message
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdditionalNodeNetworkConfig {
    /// Name of the VPC where the additional interface belongs
    pub network: std::string::String,

    /// Name of the subnetwork where the additional interface belongs
    pub subnetwork: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdditionalNodeNetworkConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [network][crate::model::AdditionalNodeNetworkConfig::network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalNodeNetworkConfig;
    /// let x = AdditionalNodeNetworkConfig::new().set_network("example");
    /// ```
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [subnetwork][crate::model::AdditionalNodeNetworkConfig::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalNodeNetworkConfig;
    /// let x = AdditionalNodeNetworkConfig::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }
}

impl wkt::message::Message for AdditionalNodeNetworkConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdditionalNodeNetworkConfig"
    }
}

/// AdditionalPodNetworkConfig is the configuration for additional pod networks
/// within the NodeNetworkConfig message
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdditionalPodNetworkConfig {
    /// Name of the subnetwork where the additional pod network belongs.
    pub subnetwork: std::string::String,

    /// The name of the secondary range on the subnet which provides IP address for
    /// this pod range.
    pub secondary_pod_range: std::string::String,

    /// The maximum number of pods per node which use this pod network.
    pub max_pods_per_node: std::option::Option<crate::model::MaxPodsConstraint>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdditionalPodNetworkConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [subnetwork][crate::model::AdditionalPodNetworkConfig::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodNetworkConfig;
    /// let x = AdditionalPodNetworkConfig::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [secondary_pod_range][crate::model::AdditionalPodNetworkConfig::secondary_pod_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodNetworkConfig;
    /// let x = AdditionalPodNetworkConfig::new().set_secondary_pod_range("example");
    /// ```
    pub fn set_secondary_pod_range<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.secondary_pod_range = v.into();
        self
    }

    /// Sets the value of [max_pods_per_node][crate::model::AdditionalPodNetworkConfig::max_pods_per_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodNetworkConfig;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = AdditionalPodNetworkConfig::new().set_max_pods_per_node(MaxPodsConstraint::default()/* use setters */);
    /// ```
    pub fn set_max_pods_per_node<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.max_pods_per_node = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [max_pods_per_node][crate::model::AdditionalPodNetworkConfig::max_pods_per_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodNetworkConfig;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = AdditionalPodNetworkConfig::new().set_or_clear_max_pods_per_node(Some(MaxPodsConstraint::default()/* use setters */));
    /// let x = AdditionalPodNetworkConfig::new().set_or_clear_max_pods_per_node(None::<MaxPodsConstraint>);
    /// ```
    pub fn set_or_clear_max_pods_per_node<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.max_pods_per_node = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AdditionalPodNetworkConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdditionalPodNetworkConfig"
    }
}

/// A set of Shielded Instance options.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ShieldedInstanceConfig {
    /// Defines whether the instance has Secure Boot enabled.
    ///
    /// Secure Boot helps ensure that the system only runs authentic software by
    /// verifying the digital signature of all boot components, and halting the
    /// boot process if signature verification fails.
    pub enable_secure_boot: bool,

    /// Defines whether the instance has integrity monitoring enabled.
    ///
    /// Enables monitoring and attestation of the boot integrity of the instance.
    /// The attestation is performed against the integrity policy baseline. This
    /// baseline is initially derived from the implicitly trusted boot image when
    /// the instance is created.
    pub enable_integrity_monitoring: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ShieldedInstanceConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_secure_boot][crate::model::ShieldedInstanceConfig::enable_secure_boot].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = ShieldedInstanceConfig::new().set_enable_secure_boot(true);
    /// ```
    pub fn set_enable_secure_boot<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_secure_boot = v.into();
        self
    }

    /// Sets the value of [enable_integrity_monitoring][crate::model::ShieldedInstanceConfig::enable_integrity_monitoring].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = ShieldedInstanceConfig::new().set_enable_integrity_monitoring(true);
    /// ```
    pub fn set_enable_integrity_monitoring<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_integrity_monitoring = v.into();
        self
    }
}

impl wkt::message::Message for ShieldedInstanceConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ShieldedInstanceConfig"
    }
}

/// CustomImageConfig contains the information r
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CustomImageConfig {
    /// The name of the image to use for this node.
    pub image: std::string::String,

    /// The project containing the image to use for this node.
    pub image_project: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CustomImageConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [image][crate::model::CustomImageConfig::image].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CustomImageConfig;
    /// let x = CustomImageConfig::new().set_image("example");
    /// ```
    pub fn set_image<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image = v.into();
        self
    }

    /// Sets the value of [image_project][crate::model::CustomImageConfig::image_project].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CustomImageConfig;
    /// let x = CustomImageConfig::new().set_image_project("example");
    /// ```
    pub fn set_image_project<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_project = v.into();
        self
    }
}

impl wkt::message::Message for CustomImageConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CustomImageConfig"
    }
}

/// SandboxConfig contains configurations of the sandbox to use for the node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SandboxConfig {
    /// Type of the sandbox to use for the node.
    pub r#type: crate::model::sandbox_config::Type,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SandboxConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [r#type][crate::model::SandboxConfig::type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SandboxConfig;
    /// use google_cloud_container_v1::model::sandbox_config::Type;
    /// let x0 = SandboxConfig::new().set_type(Type::Gvisor);
    /// ```
    pub fn set_type<T: std::convert::Into<crate::model::sandbox_config::Type>>(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }
}

impl wkt::message::Message for SandboxConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SandboxConfig"
    }
}

/// Defines additional types related to [SandboxConfig].
pub mod sandbox_config {
    #[allow(unused_imports)]
    use super::*;

    /// Possible types of sandboxes.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Default value. This should not be used.
        Unspecified,
        /// Run sandbox using gvisor.
        Gvisor,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Type::value] or
        /// [Type::name].
        UnknownValue(r#type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod r#type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Type {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Gvisor => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("UNSPECIFIED"),
                Self::Gvisor => std::option::Option::Some("GVISOR"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Type {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Type {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Type {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Gvisor,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Type {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNSPECIFIED" => Self::Unspecified,
                "GVISOR" => Self::Gvisor,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Type {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Gvisor => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Type {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                ".google.container.v1.SandboxConfig.Type",
            ))
        }
    }
}

/// GcfsConfig contains configurations of Google Container File System
/// (image streaming).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcfsConfig {
    /// Whether to use GCFS.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcfsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::GcfsConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GcfsConfig;
    /// let x = GcfsConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for GcfsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GcfsConfig"
    }
}

/// [ReservationAffinity](https://cloud.google.com/compute/docs/instances/reserving-zonal-resources)
/// is the configuration of desired reservation which instances could take
/// capacity from.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReservationAffinity {
    /// Corresponds to the type of reservation consumption.
    pub consume_reservation_type: crate::model::reservation_affinity::Type,

    /// Corresponds to the label key of a reservation resource. To target a
    /// SPECIFIC_RESERVATION by name, specify
    /// "compute.googleapis.com/reservation-name" as the key and specify the name
    /// of your reservation as its value.
    pub key: std::string::String,

    /// Corresponds to the label value(s) of reservation resource(s).
    pub values: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ReservationAffinity {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [consume_reservation_type][crate::model::ReservationAffinity::consume_reservation_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ReservationAffinity;
    /// use google_cloud_container_v1::model::reservation_affinity::Type;
    /// let x0 = ReservationAffinity::new().set_consume_reservation_type(Type::NoReservation);
    /// let x1 = ReservationAffinity::new().set_consume_reservation_type(Type::AnyReservation);
    /// let x2 = ReservationAffinity::new().set_consume_reservation_type(Type::SpecificReservation);
    /// ```
    pub fn set_consume_reservation_type<
        T: std::convert::Into<crate::model::reservation_affinity::Type>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.consume_reservation_type = v.into();
        self
    }

    /// Sets the value of [key][crate::model::ReservationAffinity::key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ReservationAffinity;
    /// let x = ReservationAffinity::new().set_key("example");
    /// ```
    pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of [values][crate::model::ReservationAffinity::values].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ReservationAffinity;
    /// let x = ReservationAffinity::new().set_values(["a", "b", "c"]);
    /// ```
    pub fn set_values<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.values = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ReservationAffinity {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ReservationAffinity"
    }
}

/// Defines additional types related to [ReservationAffinity].
pub mod reservation_affinity {
    #[allow(unused_imports)]
    use super::*;

    /// Indicates whether to consume capacity from a reservation or not.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Default value. This should not be used.
        Unspecified,
        /// Do not consume from any reserved capacity.
        NoReservation,
        /// Consume any reservation available.
        AnyReservation,
        /// Must consume from a specific reservation. Must specify key value fields
        /// for specifying the reservations.
        SpecificReservation,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Type::value] or
        /// [Type::name].
        UnknownValue(r#type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod r#type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Type {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::NoReservation => std::option::Option::Some(1),
                Self::AnyReservation => std::option::Option::Some(2),
                Self::SpecificReservation => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("UNSPECIFIED"),
                Self::NoReservation => std::option::Option::Some("NO_RESERVATION"),
                Self::AnyReservation => std::option::Option::Some("ANY_RESERVATION"),
                Self::SpecificReservation => std::option::Option::Some("SPECIFIC_RESERVATION"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Type {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Type {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Type {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::NoReservation,
                2 => Self::AnyReservation,
                3 => Self::SpecificReservation,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Type {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNSPECIFIED" => Self::Unspecified,
                "NO_RESERVATION" => Self::NoReservation,
                "ANY_RESERVATION" => Self::AnyReservation,
                "SPECIFIC_RESERVATION" => Self::SpecificReservation,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Type {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::NoReservation => serializer.serialize_i32(1),
                Self::AnyReservation => serializer.serialize_i32(2),
                Self::SpecificReservation => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Type {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                ".google.container.v1.ReservationAffinity.Type",
            ))
        }
    }
}

/// SoleTenantConfig contains the NodeAffinities to specify what shared sole
/// tenant node groups should back the node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SoleTenantConfig {
    /// NodeAffinities used to match to a shared sole tenant node group.
    pub node_affinities: std::vec::Vec<crate::model::sole_tenant_config::NodeAffinity>,

    /// Optional. The minimum number of virtual CPUs this instance will consume
    /// when running on a sole-tenant node. This field can only be set if the node
    /// pool is created in a shared sole-tenant node group.
    pub min_node_cpus: std::option::Option<i32>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SoleTenantConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [node_affinities][crate::model::SoleTenantConfig::node_affinities].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SoleTenantConfig;
    /// use google_cloud_container_v1::model::sole_tenant_config::NodeAffinity;
    /// let x = SoleTenantConfig::new()
    ///     .set_node_affinities([
    ///         NodeAffinity::default()/* use setters */,
    ///         NodeAffinity::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_node_affinities<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::sole_tenant_config::NodeAffinity>,
    {
        use std::iter::Iterator;
        self.node_affinities = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [min_node_cpus][crate::model::SoleTenantConfig::min_node_cpus].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SoleTenantConfig;
    /// let x = SoleTenantConfig::new().set_min_node_cpus(42);
    /// ```
    pub fn set_min_node_cpus<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.min_node_cpus = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [min_node_cpus][crate::model::SoleTenantConfig::min_node_cpus].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SoleTenantConfig;
    /// let x = SoleTenantConfig::new().set_or_clear_min_node_cpus(Some(42));
    /// let x = SoleTenantConfig::new().set_or_clear_min_node_cpus(None::<i32>);
    /// ```
    pub fn set_or_clear_min_node_cpus<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<i32>,
    {
        self.min_node_cpus = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SoleTenantConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SoleTenantConfig"
    }
}

/// Defines additional types related to [SoleTenantConfig].
pub mod sole_tenant_config {
    #[allow(unused_imports)]
    use super::*;

    /// Specifies the NodeAffinity key, values, and affinity operator according to
    /// [shared sole tenant node group
    /// affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity).
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NodeAffinity {
        /// Key for NodeAffinity.
        pub key: std::string::String,

        /// Operator for NodeAffinity.
        pub operator: crate::model::sole_tenant_config::node_affinity::Operator,

        /// Values for NodeAffinity.
        pub values: std::vec::Vec<std::string::String>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NodeAffinity {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [key][crate::model::sole_tenant_config::NodeAffinity::key].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::sole_tenant_config::NodeAffinity;
        /// let x = NodeAffinity::new().set_key("example");
        /// ```
        pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.key = v.into();
            self
        }

        /// Sets the value of [operator][crate::model::sole_tenant_config::NodeAffinity::operator].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::sole_tenant_config::NodeAffinity;
        /// use google_cloud_container_v1::model::sole_tenant_config::node_affinity::Operator;
        /// let x0 = NodeAffinity::new().set_operator(Operator::In);
        /// let x1 = NodeAffinity::new().set_operator(Operator::NotIn);
        /// ```
        pub fn set_operator<
            T: std::convert::Into<crate::model::sole_tenant_config::node_affinity::Operator>,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.operator = v.into();
            self
        }

        /// Sets the value of [values][crate::model::sole_tenant_config::NodeAffinity::values].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::sole_tenant_config::NodeAffinity;
        /// let x = NodeAffinity::new().set_values(["a", "b", "c"]);
        /// ```
        pub fn set_values<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.values = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for NodeAffinity {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.SoleTenantConfig.NodeAffinity"
        }
    }

    /// Defines additional types related to [NodeAffinity].
    pub mod node_affinity {
        #[allow(unused_imports)]
        use super::*;

        /// Operator allows user to specify affinity or anti-affinity for the
        /// given key values.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Operator {
            /// Invalid or unspecified affinity operator.
            Unspecified,
            /// Affinity operator.
            In,
            /// Anti-affinity operator.
            NotIn,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Operator::value] or
            /// [Operator::name].
            UnknownValue(operator::UnknownValue),
        }

        #[doc(hidden)]
        pub mod operator {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Operator {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::In => std::option::Option::Some(1),
                    Self::NotIn => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("OPERATOR_UNSPECIFIED"),
                    Self::In => std::option::Option::Some("IN"),
                    Self::NotIn => std::option::Option::Some("NOT_IN"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Operator {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Operator {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Operator {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::In,
                    2 => Self::NotIn,
                    _ => Self::UnknownValue(operator::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Operator {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "OPERATOR_UNSPECIFIED" => Self::Unspecified,
                    "IN" => Self::In,
                    "NOT_IN" => Self::NotIn,
                    _ => Self::UnknownValue(operator::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Operator {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::In => serializer.serialize_i32(1),
                    Self::NotIn => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Operator {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Operator>::new(
                    ".google.container.v1.SoleTenantConfig.NodeAffinity.Operator",
                ))
            }
        }
    }
}

/// ContainerdConfig contains configuration to customize containerd.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ContainerdConfig {
    /// PrivateRegistryAccessConfig is used to configure access configuration
    /// for private container registries.
    pub private_registry_access_config:
        std::option::Option<crate::model::containerd_config::PrivateRegistryAccessConfig>,

    /// Optional. WritableCgroups defines writable cgroups configuration for the
    /// node pool.
    pub writable_cgroups: std::option::Option<crate::model::containerd_config::WritableCgroups>,

    /// RegistryHostConfig configures containerd registry host configuration.
    /// Each registry_hosts represents a hosts.toml file.
    /// At most 25 registry_hosts are allowed.
    pub registry_hosts: std::vec::Vec<crate::model::containerd_config::RegistryHostConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ContainerdConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [private_registry_access_config][crate::model::ContainerdConfig::private_registry_access_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ContainerdConfig;
    /// use google_cloud_container_v1::model::containerd_config::PrivateRegistryAccessConfig;
    /// let x = ContainerdConfig::new().set_private_registry_access_config(PrivateRegistryAccessConfig::default()/* use setters */);
    /// ```
    pub fn set_private_registry_access_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::containerd_config::PrivateRegistryAccessConfig>,
    {
        self.private_registry_access_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [private_registry_access_config][crate::model::ContainerdConfig::private_registry_access_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ContainerdConfig;
    /// use google_cloud_container_v1::model::containerd_config::PrivateRegistryAccessConfig;
    /// let x = ContainerdConfig::new().set_or_clear_private_registry_access_config(Some(PrivateRegistryAccessConfig::default()/* use setters */));
    /// let x = ContainerdConfig::new().set_or_clear_private_registry_access_config(None::<PrivateRegistryAccessConfig>);
    /// ```
    pub fn set_or_clear_private_registry_access_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::containerd_config::PrivateRegistryAccessConfig>,
    {
        self.private_registry_access_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [writable_cgroups][crate::model::ContainerdConfig::writable_cgroups].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ContainerdConfig;
    /// use google_cloud_container_v1::model::containerd_config::WritableCgroups;
    /// let x = ContainerdConfig::new().set_writable_cgroups(WritableCgroups::default()/* use setters */);
    /// ```
    pub fn set_writable_cgroups<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::containerd_config::WritableCgroups>,
    {
        self.writable_cgroups = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [writable_cgroups][crate::model::ContainerdConfig::writable_cgroups].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ContainerdConfig;
    /// use google_cloud_container_v1::model::containerd_config::WritableCgroups;
    /// let x = ContainerdConfig::new().set_or_clear_writable_cgroups(Some(WritableCgroups::default()/* use setters */));
    /// let x = ContainerdConfig::new().set_or_clear_writable_cgroups(None::<WritableCgroups>);
    /// ```
    pub fn set_or_clear_writable_cgroups<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::containerd_config::WritableCgroups>,
    {
        self.writable_cgroups = v.map(|x| x.into());
        self
    }

    /// Sets the value of [registry_hosts][crate::model::ContainerdConfig::registry_hosts].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ContainerdConfig;
    /// use google_cloud_container_v1::model::containerd_config::RegistryHostConfig;
    /// let x = ContainerdConfig::new()
    ///     .set_registry_hosts([
    ///         RegistryHostConfig::default()/* use setters */,
    ///         RegistryHostConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_registry_hosts<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::containerd_config::RegistryHostConfig>,
    {
        use std::iter::Iterator;
        self.registry_hosts = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ContainerdConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ContainerdConfig"
    }
}

/// Defines additional types related to [ContainerdConfig].
pub mod containerd_config {
    #[allow(unused_imports)]
    use super::*;

    /// PrivateRegistryAccessConfig contains access configuration for
    /// private container registries.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PrivateRegistryAccessConfig {

        /// Private registry access is enabled.
        pub enabled: bool,

        /// Private registry access configuration.
        pub certificate_authority_domain_config: std::vec::Vec<crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl PrivateRegistryAccessConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::containerd_config::PrivateRegistryAccessConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::containerd_config::PrivateRegistryAccessConfig;
        /// let x = PrivateRegistryAccessConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }

        /// Sets the value of [certificate_authority_domain_config][crate::model::containerd_config::PrivateRegistryAccessConfig::certificate_authority_domain_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::containerd_config::PrivateRegistryAccessConfig;
        /// use google_cloud_container_v1::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig;
        /// let x = PrivateRegistryAccessConfig::new()
        ///     .set_certificate_authority_domain_config([
        ///         CertificateAuthorityDomainConfig::default()/* use setters */,
        ///         CertificateAuthorityDomainConfig::default()/* use (different) setters */,
        ///     ]);
        /// ```
        pub fn set_certificate_authority_domain_config<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig>
        {
            use std::iter::Iterator;
            self.certificate_authority_domain_config = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for PrivateRegistryAccessConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ContainerdConfig.PrivateRegistryAccessConfig"
        }
    }

    /// Defines additional types related to [PrivateRegistryAccessConfig].
    pub mod private_registry_access_config {
        #[allow(unused_imports)]
        use super::*;

        /// CertificateAuthorityDomainConfig configures one or more fully qualified
        /// domain names (FQDN) to a specific certificate.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct CertificateAuthorityDomainConfig {

            /// List of fully qualified domain names (FQDN).
            /// Specifying port is supported.
            /// Wildcards are NOT supported.
            /// Examples:
            ///
            /// - `my.customdomain.com`
            /// - `10.0.1.2:5000`
            pub fqdns: std::vec::Vec<std::string::String>,

            /// Certificate access config. The following are supported:
            ///
            /// - GCPSecretManagerCertificateConfig
            pub certificate_config: std::option::Option<crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::CertificateConfig>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl CertificateAuthorityDomainConfig {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [fqdns][crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig::fqdns].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig;
            /// let x = CertificateAuthorityDomainConfig::new().set_fqdns(["a", "b", "c"]);
            /// ```
            pub fn set_fqdns<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.fqdns = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [certificate_config][crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig::certificate_config].
            ///
            /// Note that all the setters affecting `certificate_config` are mutually
            /// exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig;
            /// use google_cloud_container_v1::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig;
            /// let x = CertificateAuthorityDomainConfig::new().set_certificate_config(Some(
            ///     google_cloud_container_v1::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::CertificateConfig::GcpSecretManagerCertificateConfig(GCPSecretManagerCertificateConfig::default().into())));
            /// ```
            pub fn set_certificate_config<T: std::convert::Into<std::option::Option<crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::CertificateConfig>>>(mut self, v: T) -> Self
            {
                self.certificate_config = v.into();
                self
            }

            /// The value of [certificate_config][crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig::certificate_config]
            /// if it holds a `GcpSecretManagerCertificateConfig`, `None` if the field is not set or
            /// holds a different branch.
            pub fn gcp_secret_manager_certificate_config(&self) -> std::option::Option<&std::boxed::Box<crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig>>{
                #[allow(unreachable_patterns)]
                self.certificate_config.as_ref().and_then(|v| match v {
                    crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::CertificateConfig::GcpSecretManagerCertificateConfig(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [certificate_config][crate::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig::certificate_config]
            /// to hold a `GcpSecretManagerCertificateConfig`.
            ///
            /// Note that all the setters affecting `certificate_config` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::private_registry_access_config::CertificateAuthorityDomainConfig;
            /// use google_cloud_container_v1::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig;
            /// let x = CertificateAuthorityDomainConfig::new().set_gcp_secret_manager_certificate_config(GCPSecretManagerCertificateConfig::default()/* use setters */);
            /// assert!(x.gcp_secret_manager_certificate_config().is_some());
            /// ```
            pub fn set_gcp_secret_manager_certificate_config<T: std::convert::Into<std::boxed::Box<crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig>>>(mut self, v: T) -> Self{
                self.certificate_config = std::option::Option::Some(
                    crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::CertificateConfig::GcpSecretManagerCertificateConfig(
                        v.into()
                    )
                );
                self
            }
        }

        impl wkt::message::Message for CertificateAuthorityDomainConfig {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.ContainerdConfig.PrivateRegistryAccessConfig.CertificateAuthorityDomainConfig"
            }
        }

        /// Defines additional types related to [CertificateAuthorityDomainConfig].
        pub mod certificate_authority_domain_config {
            #[allow(unused_imports)]
            use super::*;

            /// GCPSecretManagerCertificateConfig configures a secret from
            /// [Secret Manager](https://cloud.google.com/secret-manager).
            #[derive(Clone, Default, PartialEq)]
            #[non_exhaustive]
            pub struct GCPSecretManagerCertificateConfig {
                /// Secret URI, in the form
                /// "projects/$PROJECT_ID/secrets/$SECRET_NAME/versions/$VERSION".
                /// Version can be fixed (e.g. "2") or "latest"
                pub secret_uri: std::string::String,

                pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
            }

            impl GCPSecretManagerCertificateConfig {
                /// Creates a new default instance.
                pub fn new() -> Self {
                    std::default::Default::default()
                }

                /// Sets the value of [secret_uri][crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig::secret_uri].
                ///
                /// # Example
                /// ```ignore,no_run
                /// # use google_cloud_container_v1::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig;
                /// let x = GCPSecretManagerCertificateConfig::new().set_secret_uri("example");
                /// ```
                pub fn set_secret_uri<T: std::convert::Into<std::string::String>>(
                    mut self,
                    v: T,
                ) -> Self {
                    self.secret_uri = v.into();
                    self
                }
            }

            impl wkt::message::Message for GCPSecretManagerCertificateConfig {
                fn typename() -> &'static str {
                    "type.googleapis.com/google.container.v1.ContainerdConfig.PrivateRegistryAccessConfig.CertificateAuthorityDomainConfig.GCPSecretManagerCertificateConfig"
                }
            }

            /// Certificate access config. The following are supported:
            ///
            /// - GCPSecretManagerCertificateConfig
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum CertificateConfig {
                /// Secret Manager certificate configuration.
                GcpSecretManagerCertificateConfig(std::boxed::Box<crate::model::containerd_config::private_registry_access_config::certificate_authority_domain_config::GCPSecretManagerCertificateConfig>),
            }
        }
    }

    /// Defines writable cgroups configuration.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct WritableCgroups {
        /// Optional. Whether writable cgroups is enabled.
        pub enabled: bool,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl WritableCgroups {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::containerd_config::WritableCgroups::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::containerd_config::WritableCgroups;
        /// let x = WritableCgroups::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }
    }

    impl wkt::message::Message for WritableCgroups {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ContainerdConfig.WritableCgroups"
        }
    }

    /// RegistryHostConfig configures the top-level structure for a single
    /// containerd registry server's configuration, which represents one hosts.toml
    /// file on the node. It will override the same fqdns in
    /// PrivateRegistryAccessConfig.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RegistryHostConfig {
        /// Defines the host name of the registry server, which will be used to
        /// create configuration file as /etc/containerd/hosts.d/\<server\>/hosts.toml.
        /// It supports fully qualified domain names (FQDN) and IP addresses:
        /// Specifying port is supported, while scheme and path are NOT supported.
        /// Wildcards are NOT supported.
        /// Examples:
        ///
        /// - `my.customdomain.com`
        /// - `10.0.1.2:5000`
        pub server: std::string::String,

        /// HostConfig configures a list of host-specific configurations for the
        /// server.
        /// Each server can have at most 10 host configurations.
        pub hosts: std::vec::Vec<crate::model::containerd_config::registry_host_config::HostConfig>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl RegistryHostConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [server][crate::model::containerd_config::RegistryHostConfig::server].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::containerd_config::RegistryHostConfig;
        /// let x = RegistryHostConfig::new().set_server("example");
        /// ```
        pub fn set_server<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.server = v.into();
            self
        }

        /// Sets the value of [hosts][crate::model::containerd_config::RegistryHostConfig::hosts].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::containerd_config::RegistryHostConfig;
        /// use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
        /// let x = RegistryHostConfig::new()
        ///     .set_hosts([
        ///         HostConfig::default()/* use setters */,
        ///         HostConfig::default()/* use (different) setters */,
        ///     ]);
        /// ```
        pub fn set_hosts<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<
                    crate::model::containerd_config::registry_host_config::HostConfig,
                >,
        {
            use std::iter::Iterator;
            self.hosts = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for RegistryHostConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ContainerdConfig.RegistryHostConfig"
        }
    }

    /// Defines additional types related to [RegistryHostConfig].
    pub mod registry_host_config {
        #[allow(unused_imports)]
        use super::*;

        /// CertificateConfig configures certificate for the registry.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct CertificateConfig {

            /// One of the methods to configure the certificate.
            pub certificate: std::option::Option<crate::model::containerd_config::registry_host_config::certificate_config::Certificate>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl CertificateConfig {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [certificate][crate::model::containerd_config::registry_host_config::CertificateConfig::certificate].
            ///
            /// Note that all the setters affecting `certificate` are mutually
            /// exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::certificate_config::Certificate;
            /// let x = CertificateConfig::new().set_certificate(Some(Certificate::GcpSecretManagerSecretUri("example".to_string())));
            /// ```
            pub fn set_certificate<T: std::convert::Into<std::option::Option<crate::model::containerd_config::registry_host_config::certificate_config::Certificate>>>(mut self, v: T) -> Self
            {
                self.certificate = v.into();
                self
            }

            /// The value of [certificate][crate::model::containerd_config::registry_host_config::CertificateConfig::certificate]
            /// if it holds a `GcpSecretManagerSecretUri`, `None` if the field is not set or
            /// holds a different branch.
            pub fn gcp_secret_manager_secret_uri(
                &self,
            ) -> std::option::Option<&std::string::String> {
                #[allow(unreachable_patterns)]
                self.certificate.as_ref().and_then(|v| match v {
                    crate::model::containerd_config::registry_host_config::certificate_config::Certificate::GcpSecretManagerSecretUri(v) => std::option::Option::Some(v),
                    _ => std::option::Option::None,
                })
            }

            /// Sets the value of [certificate][crate::model::containerd_config::registry_host_config::CertificateConfig::certificate]
            /// to hold a `GcpSecretManagerSecretUri`.
            ///
            /// Note that all the setters affecting `certificate` are
            /// mutually exclusive.
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = CertificateConfig::new().set_gcp_secret_manager_secret_uri("example");
            /// assert!(x.gcp_secret_manager_secret_uri().is_some());
            /// ```
            pub fn set_gcp_secret_manager_secret_uri<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.certificate = std::option::Option::Some(
                    crate::model::containerd_config::registry_host_config::certificate_config::Certificate::GcpSecretManagerSecretUri(
                        v.into()
                    )
                );
                self
            }
        }

        impl wkt::message::Message for CertificateConfig {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.ContainerdConfig.RegistryHostConfig.CertificateConfig"
            }
        }

        /// Defines additional types related to [CertificateConfig].
        pub mod certificate_config {
            #[allow(unused_imports)]
            use super::*;

            /// One of the methods to configure the certificate.
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum Certificate {
                /// The URI configures a secret from
                /// [Secret Manager](https://cloud.google.com/secret-manager)
                /// in the format
                /// "projects/$PROJECT_ID/secrets/$SECRET_NAME/versions/$VERSION" for
                /// global secret or
                /// "projects/$PROJECT_ID/locations/$REGION/secrets/$SECRET_NAME/versions/$VERSION"
                /// for regional secret. Version can be fixed (e.g. "2") or "latest"
                GcpSecretManagerSecretUri(std::string::String),
            }
        }

        /// CertificateConfigPair configures pairs of certificates, which is used for
        /// client certificate and key pairs under a registry.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct CertificateConfigPair {
            /// Cert configures the client certificate.
            pub cert: std::option::Option<
                crate::model::containerd_config::registry_host_config::CertificateConfig,
            >,

            /// Key configures the client private key. Optional.
            pub key: std::option::Option<
                crate::model::containerd_config::registry_host_config::CertificateConfig,
            >,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl CertificateConfigPair {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [cert][crate::model::containerd_config::registry_host_config::CertificateConfigPair::cert].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfigPair;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = CertificateConfigPair::new().set_cert(CertificateConfig::default()/* use setters */);
            /// ```
            pub fn set_cert<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::CertificateConfig,
                    >,
            {
                self.cert = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [cert][crate::model::containerd_config::registry_host_config::CertificateConfigPair::cert].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfigPair;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = CertificateConfigPair::new().set_or_clear_cert(Some(CertificateConfig::default()/* use setters */));
            /// let x = CertificateConfigPair::new().set_or_clear_cert(None::<CertificateConfig>);
            /// ```
            pub fn set_or_clear_cert<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::CertificateConfig,
                    >,
            {
                self.cert = v.map(|x| x.into());
                self
            }

            /// Sets the value of [key][crate::model::containerd_config::registry_host_config::CertificateConfigPair::key].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfigPair;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = CertificateConfigPair::new().set_key(CertificateConfig::default()/* use setters */);
            /// ```
            pub fn set_key<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::CertificateConfig,
                    >,
            {
                self.key = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [key][crate::model::containerd_config::registry_host_config::CertificateConfigPair::key].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfigPair;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = CertificateConfigPair::new().set_or_clear_key(Some(CertificateConfig::default()/* use setters */));
            /// let x = CertificateConfigPair::new().set_or_clear_key(None::<CertificateConfig>);
            /// ```
            pub fn set_or_clear_key<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::CertificateConfig,
                    >,
            {
                self.key = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for CertificateConfigPair {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.ContainerdConfig.RegistryHostConfig.CertificateConfigPair"
            }
        }

        /// RegistryHeader configures headers for the registry.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct RegistryHeader {
            /// Key configures the header key.
            pub key: std::string::String,

            /// Value configures the header value.
            pub value: std::vec::Vec<std::string::String>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl RegistryHeader {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [key][crate::model::containerd_config::registry_host_config::RegistryHeader::key].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::RegistryHeader;
            /// let x = RegistryHeader::new().set_key("example");
            /// ```
            pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.key = v.into();
                self
            }

            /// Sets the value of [value][crate::model::containerd_config::registry_host_config::RegistryHeader::value].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::RegistryHeader;
            /// let x = RegistryHeader::new().set_value(["a", "b", "c"]);
            /// ```
            pub fn set_value<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.value = v.into_iter().map(|i| i.into()).collect();
                self
            }
        }

        impl wkt::message::Message for RegistryHeader {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.ContainerdConfig.RegistryHostConfig.RegistryHeader"
            }
        }

        /// HostConfig configures the registry host under a given Server.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct HostConfig {
            /// Host configures the registry host/mirror.
            /// It supports fully qualified domain names (FQDNs) and IP addresses.
            /// Specifying scheme, port or path is supported. Scheme can only be http
            /// or https.
            /// Wildcards are NOT supported.
            /// Examples:
            ///
            /// - `my.customdomain.com`
            /// - `<https://my.customdomain.com/path>`
            /// - `10.0.1.2:5000`
            pub host: std::string::String,

            /// Capabilities represent the capabilities of the registry host,
            /// specifying what operations a host is capable of performing.
            /// If not set, containerd enables all capabilities by default.
            pub capabilities: std::vec::Vec<
                crate::model::containerd_config::registry_host_config::HostCapability,
            >,

            /// OverridePath is used to indicate the host's API root endpoint is
            /// defined in the URL path rather than by the API specification. This may
            /// be used with non-compliant OCI registries which are missing the /v2
            /// prefix.
            /// If not set, containerd sets default false.
            pub override_path: bool,

            /// Header configures the registry host headers.
            pub header: std::vec::Vec<
                crate::model::containerd_config::registry_host_config::RegistryHeader,
            >,

            /// CA configures the registry host certificate.
            pub ca: std::vec::Vec<
                crate::model::containerd_config::registry_host_config::CertificateConfig,
            >,

            /// Client configures the registry host client certificate and key.
            pub client: std::vec::Vec<
                crate::model::containerd_config::registry_host_config::CertificateConfigPair,
            >,

            /// Specifies the maximum duration allowed for a connection attempt to
            /// complete. A shorter timeout helps reduce delays when falling back to
            /// the original registry if the mirror is unreachable.
            /// Maximum allowed value is 180s. If not set, containerd sets default 30s.
            /// The value should be a decimal number of seconds with an `s` suffix.
            pub dial_timeout: std::option::Option<wkt::Duration>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl HostConfig {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [host][crate::model::containerd_config::registry_host_config::HostConfig::host].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// let x = HostConfig::new().set_host("example");
            /// ```
            pub fn set_host<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
                self.host = v.into();
                self
            }

            /// Sets the value of [capabilities][crate::model::containerd_config::registry_host_config::HostConfig::capabilities].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::HostCapability;
            /// let x = HostConfig::new().set_capabilities([
            ///     HostCapability::Pull,
            ///     HostCapability::Resolve,
            ///     HostCapability::Push,
            /// ]);
            /// ```
            pub fn set_capabilities<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::HostCapability,
                    >,
            {
                use std::iter::Iterator;
                self.capabilities = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [override_path][crate::model::containerd_config::registry_host_config::HostConfig::override_path].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// let x = HostConfig::new().set_override_path(true);
            /// ```
            pub fn set_override_path<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
                self.override_path = v.into();
                self
            }

            /// Sets the value of [header][crate::model::containerd_config::registry_host_config::HostConfig::header].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::RegistryHeader;
            /// let x = HostConfig::new()
            ///     .set_header([
            ///         RegistryHeader::default()/* use setters */,
            ///         RegistryHeader::default()/* use (different) setters */,
            ///     ]);
            /// ```
            pub fn set_header<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::RegistryHeader,
                    >,
            {
                use std::iter::Iterator;
                self.header = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [ca][crate::model::containerd_config::registry_host_config::HostConfig::ca].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfig;
            /// let x = HostConfig::new()
            ///     .set_ca([
            ///         CertificateConfig::default()/* use setters */,
            ///         CertificateConfig::default()/* use (different) setters */,
            ///     ]);
            /// ```
            pub fn set_ca<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<
                        crate::model::containerd_config::registry_host_config::CertificateConfig,
                    >,
            {
                use std::iter::Iterator;
                self.ca = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [client][crate::model::containerd_config::registry_host_config::HostConfig::client].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use google_cloud_container_v1::model::containerd_config::registry_host_config::CertificateConfigPair;
            /// let x = HostConfig::new()
            ///     .set_client([
            ///         CertificateConfigPair::default()/* use setters */,
            ///         CertificateConfigPair::default()/* use (different) setters */,
            ///     ]);
            /// ```
            pub fn set_client<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<crate::model::containerd_config::registry_host_config::CertificateConfigPair>
            {
                use std::iter::Iterator;
                self.client = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [dial_timeout][crate::model::containerd_config::registry_host_config::HostConfig::dial_timeout].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use wkt::Duration;
            /// let x = HostConfig::new().set_dial_timeout(Duration::default()/* use setters */);
            /// ```
            pub fn set_dial_timeout<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<wkt::Duration>,
            {
                self.dial_timeout = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [dial_timeout][crate::model::containerd_config::registry_host_config::HostConfig::dial_timeout].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::containerd_config::registry_host_config::HostConfig;
            /// use wkt::Duration;
            /// let x = HostConfig::new().set_or_clear_dial_timeout(Some(Duration::default()/* use setters */));
            /// let x = HostConfig::new().set_or_clear_dial_timeout(None::<Duration>);
            /// ```
            pub fn set_or_clear_dial_timeout<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<wkt::Duration>,
            {
                self.dial_timeout = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for HostConfig {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.ContainerdConfig.RegistryHostConfig.HostConfig"
            }
        }

        /// HostCapability configures capabilities for the registry host.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum HostCapability {
            /// UNKNOWN should never be set.
            Unspecified,
            /// Pull represents the capability to fetch manifests and blobs by digest.
            Pull,
            /// Resolve represents the capability to fetch manifests by name.
            Resolve,
            /// Push represents the capability to push blobs and manifests.
            Push,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [HostCapability::value] or
            /// [HostCapability::name].
            UnknownValue(host_capability::UnknownValue),
        }

        #[doc(hidden)]
        pub mod host_capability {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl HostCapability {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Pull => std::option::Option::Some(1),
                    Self::Resolve => std::option::Option::Some(2),
                    Self::Push => std::option::Option::Some(3),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("HOST_CAPABILITY_UNSPECIFIED"),
                    Self::Pull => std::option::Option::Some("HOST_CAPABILITY_PULL"),
                    Self::Resolve => std::option::Option::Some("HOST_CAPABILITY_RESOLVE"),
                    Self::Push => std::option::Option::Some("HOST_CAPABILITY_PUSH"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for HostCapability {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for HostCapability {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for HostCapability {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Pull,
                    2 => Self::Resolve,
                    3 => Self::Push,
                    _ => Self::UnknownValue(host_capability::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for HostCapability {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "HOST_CAPABILITY_UNSPECIFIED" => Self::Unspecified,
                    "HOST_CAPABILITY_PULL" => Self::Pull,
                    "HOST_CAPABILITY_RESOLVE" => Self::Resolve,
                    "HOST_CAPABILITY_PUSH" => Self::Push,
                    _ => Self::UnknownValue(host_capability::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for HostCapability {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Pull => serializer.serialize_i32(1),
                    Self::Resolve => serializer.serialize_i32(2),
                    Self::Push => serializer.serialize_i32(3),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for HostCapability {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<HostCapability>::new(
                    ".google.container.v1.ContainerdConfig.RegistryHostConfig.HostCapability",
                ))
            }
        }
    }
}

/// Kubernetes taint is composed of three fields: key, value, and effect. Effect
/// can only be one of three types:  NoSchedule, PreferNoSchedule or NoExecute.
///
/// See
/// [here](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration)
/// for more information, including usage and the valid values.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeTaint {
    /// Key for taint.
    pub key: std::string::String,

    /// Value for taint.
    pub value: std::string::String,

    /// Effect for taint.
    pub effect: crate::model::node_taint::Effect,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeTaint {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [key][crate::model::NodeTaint::key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeTaint;
    /// let x = NodeTaint::new().set_key("example");
    /// ```
    pub fn set_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key = v.into();
        self
    }

    /// Sets the value of [value][crate::model::NodeTaint::value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeTaint;
    /// let x = NodeTaint::new().set_value("example");
    /// ```
    pub fn set_value<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.value = v.into();
        self
    }

    /// Sets the value of [effect][crate::model::NodeTaint::effect].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeTaint;
    /// use google_cloud_container_v1::model::node_taint::Effect;
    /// let x0 = NodeTaint::new().set_effect(Effect::NoSchedule);
    /// let x1 = NodeTaint::new().set_effect(Effect::PreferNoSchedule);
    /// let x2 = NodeTaint::new().set_effect(Effect::NoExecute);
    /// ```
    pub fn set_effect<T: std::convert::Into<crate::model::node_taint::Effect>>(
        mut self,
        v: T,
    ) -> Self {
        self.effect = v.into();
        self
    }
}

impl wkt::message::Message for NodeTaint {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeTaint"
    }
}

/// Defines additional types related to [NodeTaint].
pub mod node_taint {
    #[allow(unused_imports)]
    use super::*;

    /// Possible values for Effect in taint.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Effect {
        /// Not set
        Unspecified,
        /// NoSchedule
        NoSchedule,
        /// PreferNoSchedule
        PreferNoSchedule,
        /// NoExecute
        NoExecute,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Effect::value] or
        /// [Effect::name].
        UnknownValue(effect::UnknownValue),
    }

    #[doc(hidden)]
    pub mod effect {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Effect {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::NoSchedule => std::option::Option::Some(1),
                Self::PreferNoSchedule => std::option::Option::Some(2),
                Self::NoExecute => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EFFECT_UNSPECIFIED"),
                Self::NoSchedule => std::option::Option::Some("NO_SCHEDULE"),
                Self::PreferNoSchedule => std::option::Option::Some("PREFER_NO_SCHEDULE"),
                Self::NoExecute => std::option::Option::Some("NO_EXECUTE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Effect {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Effect {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Effect {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::NoSchedule,
                2 => Self::PreferNoSchedule,
                3 => Self::NoExecute,
                _ => Self::UnknownValue(effect::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Effect {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EFFECT_UNSPECIFIED" => Self::Unspecified,
                "NO_SCHEDULE" => Self::NoSchedule,
                "PREFER_NO_SCHEDULE" => Self::PreferNoSchedule,
                "NO_EXECUTE" => Self::NoExecute,
                _ => Self::UnknownValue(effect::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Effect {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::NoSchedule => serializer.serialize_i32(1),
                Self::PreferNoSchedule => serializer.serialize_i32(2),
                Self::NoExecute => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Effect {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Effect>::new(
                ".google.container.v1.NodeTaint.Effect",
            ))
        }
    }
}

/// Collection of Kubernetes [node
/// taints](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeTaints {
    /// List of node taints.
    pub taints: std::vec::Vec<crate::model::NodeTaint>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeTaints {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [taints][crate::model::NodeTaints::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeTaints;
    /// use google_cloud_container_v1::model::NodeTaint;
    /// let x = NodeTaints::new()
    ///     .set_taints([
    ///         NodeTaint::default()/* use setters */,
    ///         NodeTaint::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_taints<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::NodeTaint>,
    {
        use std::iter::Iterator;
        self.taints = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for NodeTaints {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeTaints"
    }
}

/// Collection of node-level [Kubernetes
/// labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeLabels {
    /// Map of node label keys and node label values.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeLabels {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [labels][crate::model::NodeLabels::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeLabels;
    /// let x = NodeLabels::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for NodeLabels {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeLabels"
    }
}

/// Collection of [Resource Manager
/// labels](https://cloud.google.com/resource-manager/docs/creating-managing-labels).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResourceLabels {
    /// Map of node label keys and node label values.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ResourceLabels {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [labels][crate::model::ResourceLabels::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceLabels;
    /// let x = ResourceLabels::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for ResourceLabels {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ResourceLabels"
    }
}

/// Collection of Compute Engine network tags that can be applied to a node's
/// underlying VM instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkTags {
    /// List of network tags.
    pub tags: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NetworkTags {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [tags][crate::model::NetworkTags::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkTags;
    /// let x = NetworkTags::new().set_tags(["a", "b", "c"]);
    /// ```
    pub fn set_tags<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.tags = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for NetworkTags {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NetworkTags"
    }
}

/// The authentication information for accessing the master endpoint.
/// Authentication can be done using HTTP basic auth or using client
/// certificates.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MasterAuth {
    /// The username to use for HTTP basic authentication to the master endpoint.
    /// For clusters v1.6.0 and later, basic authentication can be disabled by
    /// leaving username unspecified (or setting it to the empty string).
    ///
    /// Warning: basic authentication is deprecated, and will be removed in GKE
    /// control plane versions 1.19 and newer. For a list of recommended
    /// authentication methods, see:
    /// <https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication>
    #[deprecated]
    pub username: std::string::String,

    /// The password to use for HTTP basic authentication to the master endpoint.
    /// Because the master endpoint is open to the Internet, you should create a
    /// strong password.  If a password is provided for cluster creation, username
    /// must be non-empty.
    ///
    /// Warning: basic authentication is deprecated, and will be removed in GKE
    /// control plane versions 1.19 and newer. For a list of recommended
    /// authentication methods, see:
    /// <https://cloud.google.com/kubernetes-engine/docs/how-to/api-server-authentication>
    #[deprecated]
    pub password: std::string::String,

    /// Configuration for client certificate authentication on the cluster. For
    /// clusters before v1.12, if no configuration is specified, a client
    /// certificate is issued.
    pub client_certificate_config: std::option::Option<crate::model::ClientCertificateConfig>,

    /// Output only. Base64-encoded public certificate that is the root of
    /// trust for the cluster.
    pub cluster_ca_certificate: std::string::String,

    /// Output only. Base64-encoded public certificate used by clients to
    /// authenticate to the cluster endpoint. Issued only if
    /// client_certificate_config is set.
    pub client_certificate: std::string::String,

    /// Output only. Base64-encoded private key used by clients to authenticate
    /// to the cluster endpoint.
    pub client_key: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MasterAuth {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [username][crate::model::MasterAuth::username].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// let x = MasterAuth::new().set_username("example");
    /// ```
    #[deprecated]
    pub fn set_username<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.username = v.into();
        self
    }

    /// Sets the value of [password][crate::model::MasterAuth::password].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// let x = MasterAuth::new().set_password("example");
    /// ```
    #[deprecated]
    pub fn set_password<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.password = v.into();
        self
    }

    /// Sets the value of [client_certificate_config][crate::model::MasterAuth::client_certificate_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// use google_cloud_container_v1::model::ClientCertificateConfig;
    /// let x = MasterAuth::new().set_client_certificate_config(ClientCertificateConfig::default()/* use setters */);
    /// ```
    pub fn set_client_certificate_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClientCertificateConfig>,
    {
        self.client_certificate_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [client_certificate_config][crate::model::MasterAuth::client_certificate_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// use google_cloud_container_v1::model::ClientCertificateConfig;
    /// let x = MasterAuth::new().set_or_clear_client_certificate_config(Some(ClientCertificateConfig::default()/* use setters */));
    /// let x = MasterAuth::new().set_or_clear_client_certificate_config(None::<ClientCertificateConfig>);
    /// ```
    pub fn set_or_clear_client_certificate_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ClientCertificateConfig>,
    {
        self.client_certificate_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cluster_ca_certificate][crate::model::MasterAuth::cluster_ca_certificate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// let x = MasterAuth::new().set_cluster_ca_certificate("example");
    /// ```
    pub fn set_cluster_ca_certificate<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_ca_certificate = v.into();
        self
    }

    /// Sets the value of [client_certificate][crate::model::MasterAuth::client_certificate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// let x = MasterAuth::new().set_client_certificate("example");
    /// ```
    pub fn set_client_certificate<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.client_certificate = v.into();
        self
    }

    /// Sets the value of [client_key][crate::model::MasterAuth::client_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuth;
    /// let x = MasterAuth::new().set_client_key("example");
    /// ```
    pub fn set_client_key<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.client_key = v.into();
        self
    }
}

impl wkt::message::Message for MasterAuth {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MasterAuth"
    }
}

/// Configuration for client certificates on the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClientCertificateConfig {
    /// Issue a client certificate.
    pub issue_client_certificate: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ClientCertificateConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [issue_client_certificate][crate::model::ClientCertificateConfig::issue_client_certificate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClientCertificateConfig;
    /// let x = ClientCertificateConfig::new().set_issue_client_certificate(true);
    /// ```
    pub fn set_issue_client_certificate<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.issue_client_certificate = v.into();
        self
    }
}

impl wkt::message::Message for ClientCertificateConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ClientCertificateConfig"
    }
}

/// Configuration for the addons that can be automatically spun up in the
/// cluster, enabling additional functionality.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AddonsConfig {
    /// Configuration for the HTTP (L7) load balancing controller addon, which
    /// makes it easy to set up HTTP load balancers for services in a cluster.
    pub http_load_balancing: std::option::Option<crate::model::HttpLoadBalancing>,

    /// Configuration for the horizontal pod autoscaling feature, which
    /// increases or decreases the number of replica pods a replication controller
    /// has based on the resource usage of the existing pods.
    pub horizontal_pod_autoscaling: std::option::Option<crate::model::HorizontalPodAutoscaling>,

    /// Configuration for the Kubernetes Dashboard.
    /// This addon is deprecated, and will be disabled in 1.15. It is recommended
    /// to use the Cloud Console to manage and monitor your Kubernetes clusters,
    /// workloads and applications. For more information, see:
    /// <https://cloud.google.com/kubernetes-engine/docs/concepts/dashboards>
    #[deprecated]
    pub kubernetes_dashboard: std::option::Option<crate::model::KubernetesDashboard>,

    /// Configuration for NetworkPolicy. This only tracks whether the addon
    /// is enabled or not on the Master, it does not track whether network policy
    /// is enabled for the nodes.
    pub network_policy_config: std::option::Option<crate::model::NetworkPolicyConfig>,

    /// Configuration for the Cloud Run addon, which allows the user to use a
    /// managed Knative service.
    pub cloud_run_config: std::option::Option<crate::model::CloudRunConfig>,

    /// Configuration for NodeLocalDNS, a dns cache running on cluster nodes
    pub dns_cache_config: std::option::Option<crate::model::DnsCacheConfig>,

    /// Configuration for the ConfigConnector add-on, a Kubernetes
    /// extension to manage hosted Google Cloud services through the Kubernetes
    /// API.
    pub config_connector_config: std::option::Option<crate::model::ConfigConnectorConfig>,

    /// Configuration for the Compute Engine Persistent Disk CSI driver.
    pub gce_persistent_disk_csi_driver_config:
        std::option::Option<crate::model::GcePersistentDiskCsiDriverConfig>,

    /// Configuration for the Filestore CSI driver.
    pub gcp_filestore_csi_driver_config:
        std::option::Option<crate::model::GcpFilestoreCsiDriverConfig>,

    /// Configuration for the Backup for GKE agent addon.
    pub gke_backup_agent_config: std::option::Option<crate::model::GkeBackupAgentConfig>,

    /// Configuration for the Cloud Storage Fuse CSI driver.
    pub gcs_fuse_csi_driver_config: std::option::Option<crate::model::GcsFuseCsiDriverConfig>,

    /// Optional. Configuration for the StatefulHA add-on.
    pub stateful_ha_config: std::option::Option<crate::model::StatefulHAConfig>,

    /// Configuration for the Cloud Storage Parallelstore CSI driver.
    pub parallelstore_csi_driver_config:
        std::option::Option<crate::model::ParallelstoreCsiDriverConfig>,

    /// Optional. Configuration for Ray Operator addon.
    pub ray_operator_config: std::option::Option<crate::model::RayOperatorConfig>,

    /// Configuration for the High Scale Checkpointing add-on.
    pub high_scale_checkpointing_config:
        std::option::Option<crate::model::HighScaleCheckpointingConfig>,

    /// Configuration for the Lustre CSI driver.
    pub lustre_csi_driver_config: std::option::Option<crate::model::LustreCsiDriverConfig>,

    /// Optional. Configuration for the Pod Snapshot feature.
    pub pod_snapshot_config: std::option::Option<crate::model::PodSnapshotConfig>,

    /// Configuration for the Slurm Operator.
    pub slurm_operator_config: std::option::Option<crate::model::SlurmOperatorConfig>,

    /// Optional. Configuration for the slice controller add-on.
    pub slice_controller_config: std::option::Option<crate::model::SliceControllerConfig>,

    /// Optional. Configuration for the AgentSandbox addon.
    pub agent_sandbox_config: std::option::Option<crate::model::AgentSandboxConfig>,

    /// Optional. Configuration for NodeReadinessController add-on.
    pub node_readiness_config: std::option::Option<crate::model::NodeReadinessConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AddonsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [http_load_balancing][crate::model::AddonsConfig::http_load_balancing].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HttpLoadBalancing;
    /// let x = AddonsConfig::new().set_http_load_balancing(HttpLoadBalancing::default()/* use setters */);
    /// ```
    pub fn set_http_load_balancing<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::HttpLoadBalancing>,
    {
        self.http_load_balancing = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [http_load_balancing][crate::model::AddonsConfig::http_load_balancing].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HttpLoadBalancing;
    /// let x = AddonsConfig::new().set_or_clear_http_load_balancing(Some(HttpLoadBalancing::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_http_load_balancing(None::<HttpLoadBalancing>);
    /// ```
    pub fn set_or_clear_http_load_balancing<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::HttpLoadBalancing>,
    {
        self.http_load_balancing = v.map(|x| x.into());
        self
    }

    /// Sets the value of [horizontal_pod_autoscaling][crate::model::AddonsConfig::horizontal_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HorizontalPodAutoscaling;
    /// let x = AddonsConfig::new().set_horizontal_pod_autoscaling(HorizontalPodAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_horizontal_pod_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::HorizontalPodAutoscaling>,
    {
        self.horizontal_pod_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [horizontal_pod_autoscaling][crate::model::AddonsConfig::horizontal_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HorizontalPodAutoscaling;
    /// let x = AddonsConfig::new().set_or_clear_horizontal_pod_autoscaling(Some(HorizontalPodAutoscaling::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_horizontal_pod_autoscaling(None::<HorizontalPodAutoscaling>);
    /// ```
    pub fn set_or_clear_horizontal_pod_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::HorizontalPodAutoscaling>,
    {
        self.horizontal_pod_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [kubernetes_dashboard][crate::model::AddonsConfig::kubernetes_dashboard].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::KubernetesDashboard;
    /// let x = AddonsConfig::new().set_kubernetes_dashboard(KubernetesDashboard::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_kubernetes_dashboard<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::KubernetesDashboard>,
    {
        self.kubernetes_dashboard = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [kubernetes_dashboard][crate::model::AddonsConfig::kubernetes_dashboard].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::KubernetesDashboard;
    /// let x = AddonsConfig::new().set_or_clear_kubernetes_dashboard(Some(KubernetesDashboard::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_kubernetes_dashboard(None::<KubernetesDashboard>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_kubernetes_dashboard<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::KubernetesDashboard>,
    {
        self.kubernetes_dashboard = v.map(|x| x.into());
        self
    }

    /// Sets the value of [network_policy_config][crate::model::AddonsConfig::network_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::NetworkPolicyConfig;
    /// let x = AddonsConfig::new().set_network_policy_config(NetworkPolicyConfig::default()/* use setters */);
    /// ```
    pub fn set_network_policy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicyConfig>,
    {
        self.network_policy_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_policy_config][crate::model::AddonsConfig::network_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::NetworkPolicyConfig;
    /// let x = AddonsConfig::new().set_or_clear_network_policy_config(Some(NetworkPolicyConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_network_policy_config(None::<NetworkPolicyConfig>);
    /// ```
    pub fn set_or_clear_network_policy_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicyConfig>,
    {
        self.network_policy_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cloud_run_config][crate::model::AddonsConfig::cloud_run_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::CloudRunConfig;
    /// let x = AddonsConfig::new().set_cloud_run_config(CloudRunConfig::default()/* use setters */);
    /// ```
    pub fn set_cloud_run_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CloudRunConfig>,
    {
        self.cloud_run_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cloud_run_config][crate::model::AddonsConfig::cloud_run_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::CloudRunConfig;
    /// let x = AddonsConfig::new().set_or_clear_cloud_run_config(Some(CloudRunConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_cloud_run_config(None::<CloudRunConfig>);
    /// ```
    pub fn set_or_clear_cloud_run_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CloudRunConfig>,
    {
        self.cloud_run_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [dns_cache_config][crate::model::AddonsConfig::dns_cache_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::DnsCacheConfig;
    /// let x = AddonsConfig::new().set_dns_cache_config(DnsCacheConfig::default()/* use setters */);
    /// ```
    pub fn set_dns_cache_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DnsCacheConfig>,
    {
        self.dns_cache_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [dns_cache_config][crate::model::AddonsConfig::dns_cache_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::DnsCacheConfig;
    /// let x = AddonsConfig::new().set_or_clear_dns_cache_config(Some(DnsCacheConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_dns_cache_config(None::<DnsCacheConfig>);
    /// ```
    pub fn set_or_clear_dns_cache_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DnsCacheConfig>,
    {
        self.dns_cache_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [config_connector_config][crate::model::AddonsConfig::config_connector_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::ConfigConnectorConfig;
    /// let x = AddonsConfig::new().set_config_connector_config(ConfigConnectorConfig::default()/* use setters */);
    /// ```
    pub fn set_config_connector_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ConfigConnectorConfig>,
    {
        self.config_connector_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [config_connector_config][crate::model::AddonsConfig::config_connector_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::ConfigConnectorConfig;
    /// let x = AddonsConfig::new().set_or_clear_config_connector_config(Some(ConfigConnectorConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_config_connector_config(None::<ConfigConnectorConfig>);
    /// ```
    pub fn set_or_clear_config_connector_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ConfigConnectorConfig>,
    {
        self.config_connector_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gce_persistent_disk_csi_driver_config][crate::model::AddonsConfig::gce_persistent_disk_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcePersistentDiskCsiDriverConfig;
    /// let x = AddonsConfig::new().set_gce_persistent_disk_csi_driver_config(GcePersistentDiskCsiDriverConfig::default()/* use setters */);
    /// ```
    pub fn set_gce_persistent_disk_csi_driver_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcePersistentDiskCsiDriverConfig>,
    {
        self.gce_persistent_disk_csi_driver_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gce_persistent_disk_csi_driver_config][crate::model::AddonsConfig::gce_persistent_disk_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcePersistentDiskCsiDriverConfig;
    /// let x = AddonsConfig::new().set_or_clear_gce_persistent_disk_csi_driver_config(Some(GcePersistentDiskCsiDriverConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_gce_persistent_disk_csi_driver_config(None::<GcePersistentDiskCsiDriverConfig>);
    /// ```
    pub fn set_or_clear_gce_persistent_disk_csi_driver_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::GcePersistentDiskCsiDriverConfig>,
    {
        self.gce_persistent_disk_csi_driver_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gcp_filestore_csi_driver_config][crate::model::AddonsConfig::gcp_filestore_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcpFilestoreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_gcp_filestore_csi_driver_config(GcpFilestoreCsiDriverConfig::default()/* use setters */);
    /// ```
    pub fn set_gcp_filestore_csi_driver_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcpFilestoreCsiDriverConfig>,
    {
        self.gcp_filestore_csi_driver_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcp_filestore_csi_driver_config][crate::model::AddonsConfig::gcp_filestore_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcpFilestoreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_or_clear_gcp_filestore_csi_driver_config(Some(GcpFilestoreCsiDriverConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_gcp_filestore_csi_driver_config(None::<GcpFilestoreCsiDriverConfig>);
    /// ```
    pub fn set_or_clear_gcp_filestore_csi_driver_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::GcpFilestoreCsiDriverConfig>,
    {
        self.gcp_filestore_csi_driver_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gke_backup_agent_config][crate::model::AddonsConfig::gke_backup_agent_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GkeBackupAgentConfig;
    /// let x = AddonsConfig::new().set_gke_backup_agent_config(GkeBackupAgentConfig::default()/* use setters */);
    /// ```
    pub fn set_gke_backup_agent_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GkeBackupAgentConfig>,
    {
        self.gke_backup_agent_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gke_backup_agent_config][crate::model::AddonsConfig::gke_backup_agent_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GkeBackupAgentConfig;
    /// let x = AddonsConfig::new().set_or_clear_gke_backup_agent_config(Some(GkeBackupAgentConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_gke_backup_agent_config(None::<GkeBackupAgentConfig>);
    /// ```
    pub fn set_or_clear_gke_backup_agent_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GkeBackupAgentConfig>,
    {
        self.gke_backup_agent_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gcs_fuse_csi_driver_config][crate::model::AddonsConfig::gcs_fuse_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcsFuseCsiDriverConfig;
    /// let x = AddonsConfig::new().set_gcs_fuse_csi_driver_config(GcsFuseCsiDriverConfig::default()/* use setters */);
    /// ```
    pub fn set_gcs_fuse_csi_driver_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcsFuseCsiDriverConfig>,
    {
        self.gcs_fuse_csi_driver_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcs_fuse_csi_driver_config][crate::model::AddonsConfig::gcs_fuse_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::GcsFuseCsiDriverConfig;
    /// let x = AddonsConfig::new().set_or_clear_gcs_fuse_csi_driver_config(Some(GcsFuseCsiDriverConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_gcs_fuse_csi_driver_config(None::<GcsFuseCsiDriverConfig>);
    /// ```
    pub fn set_or_clear_gcs_fuse_csi_driver_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GcsFuseCsiDriverConfig>,
    {
        self.gcs_fuse_csi_driver_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [stateful_ha_config][crate::model::AddonsConfig::stateful_ha_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::StatefulHAConfig;
    /// let x = AddonsConfig::new().set_stateful_ha_config(StatefulHAConfig::default()/* use setters */);
    /// ```
    pub fn set_stateful_ha_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::StatefulHAConfig>,
    {
        self.stateful_ha_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [stateful_ha_config][crate::model::AddonsConfig::stateful_ha_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::StatefulHAConfig;
    /// let x = AddonsConfig::new().set_or_clear_stateful_ha_config(Some(StatefulHAConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_stateful_ha_config(None::<StatefulHAConfig>);
    /// ```
    pub fn set_or_clear_stateful_ha_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::StatefulHAConfig>,
    {
        self.stateful_ha_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [parallelstore_csi_driver_config][crate::model::AddonsConfig::parallelstore_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::ParallelstoreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_parallelstore_csi_driver_config(ParallelstoreCsiDriverConfig::default()/* use setters */);
    /// ```
    pub fn set_parallelstore_csi_driver_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ParallelstoreCsiDriverConfig>,
    {
        self.parallelstore_csi_driver_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [parallelstore_csi_driver_config][crate::model::AddonsConfig::parallelstore_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::ParallelstoreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_or_clear_parallelstore_csi_driver_config(Some(ParallelstoreCsiDriverConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_parallelstore_csi_driver_config(None::<ParallelstoreCsiDriverConfig>);
    /// ```
    pub fn set_or_clear_parallelstore_csi_driver_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ParallelstoreCsiDriverConfig>,
    {
        self.parallelstore_csi_driver_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ray_operator_config][crate::model::AddonsConfig::ray_operator_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::RayOperatorConfig;
    /// let x = AddonsConfig::new().set_ray_operator_config(RayOperatorConfig::default()/* use setters */);
    /// ```
    pub fn set_ray_operator_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RayOperatorConfig>,
    {
        self.ray_operator_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ray_operator_config][crate::model::AddonsConfig::ray_operator_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::RayOperatorConfig;
    /// let x = AddonsConfig::new().set_or_clear_ray_operator_config(Some(RayOperatorConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_ray_operator_config(None::<RayOperatorConfig>);
    /// ```
    pub fn set_or_clear_ray_operator_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RayOperatorConfig>,
    {
        self.ray_operator_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [high_scale_checkpointing_config][crate::model::AddonsConfig::high_scale_checkpointing_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HighScaleCheckpointingConfig;
    /// let x = AddonsConfig::new().set_high_scale_checkpointing_config(HighScaleCheckpointingConfig::default()/* use setters */);
    /// ```
    pub fn set_high_scale_checkpointing_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::HighScaleCheckpointingConfig>,
    {
        self.high_scale_checkpointing_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [high_scale_checkpointing_config][crate::model::AddonsConfig::high_scale_checkpointing_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::HighScaleCheckpointingConfig;
    /// let x = AddonsConfig::new().set_or_clear_high_scale_checkpointing_config(Some(HighScaleCheckpointingConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_high_scale_checkpointing_config(None::<HighScaleCheckpointingConfig>);
    /// ```
    pub fn set_or_clear_high_scale_checkpointing_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::HighScaleCheckpointingConfig>,
    {
        self.high_scale_checkpointing_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [lustre_csi_driver_config][crate::model::AddonsConfig::lustre_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::LustreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_lustre_csi_driver_config(LustreCsiDriverConfig::default()/* use setters */);
    /// ```
    pub fn set_lustre_csi_driver_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LustreCsiDriverConfig>,
    {
        self.lustre_csi_driver_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [lustre_csi_driver_config][crate::model::AddonsConfig::lustre_csi_driver_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::LustreCsiDriverConfig;
    /// let x = AddonsConfig::new().set_or_clear_lustre_csi_driver_config(Some(LustreCsiDriverConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_lustre_csi_driver_config(None::<LustreCsiDriverConfig>);
    /// ```
    pub fn set_or_clear_lustre_csi_driver_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LustreCsiDriverConfig>,
    {
        self.lustre_csi_driver_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [pod_snapshot_config][crate::model::AddonsConfig::pod_snapshot_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::PodSnapshotConfig;
    /// let x = AddonsConfig::new().set_pod_snapshot_config(PodSnapshotConfig::default()/* use setters */);
    /// ```
    pub fn set_pod_snapshot_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PodSnapshotConfig>,
    {
        self.pod_snapshot_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pod_snapshot_config][crate::model::AddonsConfig::pod_snapshot_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::PodSnapshotConfig;
    /// let x = AddonsConfig::new().set_or_clear_pod_snapshot_config(Some(PodSnapshotConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_pod_snapshot_config(None::<PodSnapshotConfig>);
    /// ```
    pub fn set_or_clear_pod_snapshot_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PodSnapshotConfig>,
    {
        self.pod_snapshot_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [slurm_operator_config][crate::model::AddonsConfig::slurm_operator_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::SlurmOperatorConfig;
    /// let x = AddonsConfig::new().set_slurm_operator_config(SlurmOperatorConfig::default()/* use setters */);
    /// ```
    pub fn set_slurm_operator_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SlurmOperatorConfig>,
    {
        self.slurm_operator_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [slurm_operator_config][crate::model::AddonsConfig::slurm_operator_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::SlurmOperatorConfig;
    /// let x = AddonsConfig::new().set_or_clear_slurm_operator_config(Some(SlurmOperatorConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_slurm_operator_config(None::<SlurmOperatorConfig>);
    /// ```
    pub fn set_or_clear_slurm_operator_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SlurmOperatorConfig>,
    {
        self.slurm_operator_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [slice_controller_config][crate::model::AddonsConfig::slice_controller_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::SliceControllerConfig;
    /// let x = AddonsConfig::new().set_slice_controller_config(SliceControllerConfig::default()/* use setters */);
    /// ```
    pub fn set_slice_controller_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SliceControllerConfig>,
    {
        self.slice_controller_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [slice_controller_config][crate::model::AddonsConfig::slice_controller_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::SliceControllerConfig;
    /// let x = AddonsConfig::new().set_or_clear_slice_controller_config(Some(SliceControllerConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_slice_controller_config(None::<SliceControllerConfig>);
    /// ```
    pub fn set_or_clear_slice_controller_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SliceControllerConfig>,
    {
        self.slice_controller_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [agent_sandbox_config][crate::model::AddonsConfig::agent_sandbox_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::AgentSandboxConfig;
    /// let x = AddonsConfig::new().set_agent_sandbox_config(AgentSandboxConfig::default()/* use setters */);
    /// ```
    pub fn set_agent_sandbox_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AgentSandboxConfig>,
    {
        self.agent_sandbox_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [agent_sandbox_config][crate::model::AddonsConfig::agent_sandbox_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::AgentSandboxConfig;
    /// let x = AddonsConfig::new().set_or_clear_agent_sandbox_config(Some(AgentSandboxConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_agent_sandbox_config(None::<AgentSandboxConfig>);
    /// ```
    pub fn set_or_clear_agent_sandbox_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AgentSandboxConfig>,
    {
        self.agent_sandbox_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_readiness_config][crate::model::AddonsConfig::node_readiness_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::NodeReadinessConfig;
    /// let x = AddonsConfig::new().set_node_readiness_config(NodeReadinessConfig::default()/* use setters */);
    /// ```
    pub fn set_node_readiness_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeReadinessConfig>,
    {
        self.node_readiness_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_readiness_config][crate::model::AddonsConfig::node_readiness_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AddonsConfig;
    /// use google_cloud_container_v1::model::NodeReadinessConfig;
    /// let x = AddonsConfig::new().set_or_clear_node_readiness_config(Some(NodeReadinessConfig::default()/* use setters */));
    /// let x = AddonsConfig::new().set_or_clear_node_readiness_config(None::<NodeReadinessConfig>);
    /// ```
    pub fn set_or_clear_node_readiness_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeReadinessConfig>,
    {
        self.node_readiness_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AddonsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AddonsConfig"
    }
}

/// Configuration options for the HTTP (L7) load balancing controller addon,
/// which makes it easy to set up HTTP load balancers for services in a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct HttpLoadBalancing {
    /// Whether the HTTP Load Balancing controller is enabled in the cluster.
    /// When enabled, it runs a small pod in the cluster that manages the load
    /// balancers.
    pub disabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl HttpLoadBalancing {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::HttpLoadBalancing::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::HttpLoadBalancing;
    /// let x = HttpLoadBalancing::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }
}

impl wkt::message::Message for HttpLoadBalancing {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.HttpLoadBalancing"
    }
}

/// Configuration options for the horizontal pod autoscaling feature, which
/// increases or decreases the number of replica pods a replication controller
/// has based on the resource usage of the existing pods.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct HorizontalPodAutoscaling {
    /// Whether the Horizontal Pod Autoscaling feature is enabled in the cluster.
    /// When enabled, it ensures that metrics are collected into Stackdriver
    /// Monitoring.
    pub disabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl HorizontalPodAutoscaling {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::HorizontalPodAutoscaling::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::HorizontalPodAutoscaling;
    /// let x = HorizontalPodAutoscaling::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }
}

impl wkt::message::Message for HorizontalPodAutoscaling {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.HorizontalPodAutoscaling"
    }
}

/// Configuration for the Kubernetes Dashboard.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct KubernetesDashboard {
    /// Whether the Kubernetes Dashboard is enabled for this cluster.
    pub disabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl KubernetesDashboard {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::KubernetesDashboard::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::KubernetesDashboard;
    /// let x = KubernetesDashboard::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }
}

impl wkt::message::Message for KubernetesDashboard {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.KubernetesDashboard"
    }
}

/// Configuration for NetworkPolicy. This only tracks whether the addon
/// is enabled or not on the Master, it does not track whether network policy
/// is enabled for the nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkPolicyConfig {
    /// Whether NetworkPolicy is enabled for this cluster.
    pub disabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NetworkPolicyConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::NetworkPolicyConfig::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkPolicyConfig;
    /// let x = NetworkPolicyConfig::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }
}

impl wkt::message::Message for NetworkPolicyConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NetworkPolicyConfig"
    }
}

/// Configuration for NodeLocal DNSCache
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DnsCacheConfig {
    /// Whether NodeLocal DNSCache is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DnsCacheConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::DnsCacheConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DnsCacheConfig;
    /// let x = DnsCacheConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for DnsCacheConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DnsCacheConfig"
    }
}

/// Configuration for controlling master global access settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PrivateClusterMasterGlobalAccessConfig {
    /// Whenever master is accessible globally or not.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PrivateClusterMasterGlobalAccessConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::PrivateClusterMasterGlobalAccessConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterMasterGlobalAccessConfig;
    /// let x = PrivateClusterMasterGlobalAccessConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for PrivateClusterMasterGlobalAccessConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PrivateClusterMasterGlobalAccessConfig"
    }
}

/// Configuration options for private clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PrivateClusterConfig {
    /// Whether nodes have internal IP addresses only. If enabled, all nodes are
    /// given only RFC 1918 private addresses and communicate with the master via
    /// private networking.
    ///
    /// Deprecated: Use
    /// [NetworkConfig.default_enable_private_nodes][google.container.v1.NetworkConfig.default_enable_private_nodes]
    /// instead.
    ///
    /// [google.container.v1.NetworkConfig.default_enable_private_nodes]: crate::model::NetworkConfig::default_enable_private_nodes
    #[deprecated]
    pub enable_private_nodes: bool,

    /// Whether the master's internal IP address is used as the cluster endpoint.
    ///
    /// Deprecated: Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.enable_public_endpoint][google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.enable_public_endpoint]
    /// instead. Note that the value of enable_public_endpoint is reversed: if
    /// enable_private_endpoint is false, then enable_public_endpoint will be true.
    ///
    /// [google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.enable_public_endpoint]: crate::model::control_plane_endpoints_config::IPEndpointsConfig::enable_public_endpoint
    #[deprecated]
    pub enable_private_endpoint: bool,

    /// The IP range in CIDR notation to use for the hosted master network. This
    /// range will be used for assigning internal IP addresses to the master or
    /// set of masters, as well as the ILB VIP. This range must not overlap with
    /// any other ranges in use within the cluster's network.
    pub master_ipv4_cidr_block: std::string::String,

    /// Output only. The internal IP address of this cluster's master endpoint.
    ///
    /// Deprecated: Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint][google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint]
    /// instead.
    ///
    /// [google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint]: crate::model::control_plane_endpoints_config::IPEndpointsConfig::private_endpoint
    #[deprecated]
    pub private_endpoint: std::string::String,

    /// Output only. The external IP address of this cluster's master endpoint.
    ///
    /// Deprecated:Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.public_endpoint][google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.public_endpoint]
    /// instead.
    ///
    /// [google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.public_endpoint]: crate::model::control_plane_endpoints_config::IPEndpointsConfig::public_endpoint
    #[deprecated]
    pub public_endpoint: std::string::String,

    /// Output only. The peering name in the customer VPC used by this cluster.
    pub peering_name: std::string::String,

    /// Controls master global access settings.
    ///
    /// Deprecated: Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.enable_global_access][]
    /// instead.
    #[deprecated]
    pub master_global_access_config:
        std::option::Option<crate::model::PrivateClusterMasterGlobalAccessConfig>,

    /// Subnet to provision the master's private endpoint during cluster creation.
    /// Specified in projects/*/regions/*/subnetworks/* format.
    ///
    /// Deprecated: Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint_subnetwork][google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint_subnetwork]
    /// instead.
    ///
    /// [google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.private_endpoint_subnetwork]: crate::model::control_plane_endpoints_config::IPEndpointsConfig::private_endpoint_subnetwork
    #[deprecated]
    pub private_endpoint_subnetwork: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PrivateClusterConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_private_nodes][crate::model::PrivateClusterConfig::enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_enable_private_nodes(true);
    /// ```
    #[deprecated]
    pub fn set_enable_private_nodes<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_private_nodes = v.into();
        self
    }

    /// Sets the value of [enable_private_endpoint][crate::model::PrivateClusterConfig::enable_private_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_enable_private_endpoint(true);
    /// ```
    #[deprecated]
    pub fn set_enable_private_endpoint<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_private_endpoint = v.into();
        self
    }

    /// Sets the value of [master_ipv4_cidr_block][crate::model::PrivateClusterConfig::master_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_master_ipv4_cidr_block("example");
    /// ```
    pub fn set_master_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.master_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [private_endpoint][crate::model::PrivateClusterConfig::private_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_private_endpoint("example");
    /// ```
    #[deprecated]
    pub fn set_private_endpoint<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.private_endpoint = v.into();
        self
    }

    /// Sets the value of [public_endpoint][crate::model::PrivateClusterConfig::public_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_public_endpoint("example");
    /// ```
    #[deprecated]
    pub fn set_public_endpoint<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.public_endpoint = v.into();
        self
    }

    /// Sets the value of [peering_name][crate::model::PrivateClusterConfig::peering_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_peering_name("example");
    /// ```
    pub fn set_peering_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.peering_name = v.into();
        self
    }

    /// Sets the value of [master_global_access_config][crate::model::PrivateClusterConfig::master_global_access_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// use google_cloud_container_v1::model::PrivateClusterMasterGlobalAccessConfig;
    /// let x = PrivateClusterConfig::new().set_master_global_access_config(PrivateClusterMasterGlobalAccessConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_master_global_access_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterMasterGlobalAccessConfig>,
    {
        self.master_global_access_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [master_global_access_config][crate::model::PrivateClusterConfig::master_global_access_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// use google_cloud_container_v1::model::PrivateClusterMasterGlobalAccessConfig;
    /// let x = PrivateClusterConfig::new().set_or_clear_master_global_access_config(Some(PrivateClusterMasterGlobalAccessConfig::default()/* use setters */));
    /// let x = PrivateClusterConfig::new().set_or_clear_master_global_access_config(None::<PrivateClusterMasterGlobalAccessConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_master_global_access_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterMasterGlobalAccessConfig>,
    {
        self.master_global_access_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [private_endpoint_subnetwork][crate::model::PrivateClusterConfig::private_endpoint_subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = PrivateClusterConfig::new().set_private_endpoint_subnetwork("example");
    /// ```
    #[deprecated]
    pub fn set_private_endpoint_subnetwork<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.private_endpoint_subnetwork = v.into();
        self
    }
}

impl wkt::message::Message for PrivateClusterConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PrivateClusterConfig"
    }
}

/// Configuration for returning group information from authenticators.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AuthenticatorGroupsConfig {
    /// Whether this cluster should return group membership lookups
    /// during authentication using a group of security groups.
    pub enabled: bool,

    /// The name of the security group-of-groups to be used. Only relevant
    /// if enabled = true.
    pub security_group: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AuthenticatorGroupsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::AuthenticatorGroupsConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = AuthenticatorGroupsConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [security_group][crate::model::AuthenticatorGroupsConfig::security_group].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = AuthenticatorGroupsConfig::new().set_security_group("example");
    /// ```
    pub fn set_security_group<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.security_group = v.into();
        self
    }
}

impl wkt::message::Message for AuthenticatorGroupsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AuthenticatorGroupsConfig"
    }
}

/// Configuration options for the Cloud Run feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CloudRunConfig {
    /// Whether Cloud Run addon is enabled for this cluster.
    pub disabled: bool,

    /// Which load balancer type is installed for Cloud Run.
    pub load_balancer_type: crate::model::cloud_run_config::LoadBalancerType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CloudRunConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::CloudRunConfig::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CloudRunConfig;
    /// let x = CloudRunConfig::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }

    /// Sets the value of [load_balancer_type][crate::model::CloudRunConfig::load_balancer_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CloudRunConfig;
    /// use google_cloud_container_v1::model::cloud_run_config::LoadBalancerType;
    /// let x0 = CloudRunConfig::new().set_load_balancer_type(LoadBalancerType::External);
    /// let x1 = CloudRunConfig::new().set_load_balancer_type(LoadBalancerType::Internal);
    /// ```
    pub fn set_load_balancer_type<
        T: std::convert::Into<crate::model::cloud_run_config::LoadBalancerType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.load_balancer_type = v.into();
        self
    }
}

impl wkt::message::Message for CloudRunConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CloudRunConfig"
    }
}

/// Defines additional types related to [CloudRunConfig].
pub mod cloud_run_config {
    #[allow(unused_imports)]
    use super::*;

    /// Load balancer type of ingress service of Cloud Run.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LoadBalancerType {
        /// Load balancer type for Cloud Run is unspecified.
        Unspecified,
        /// Install external load balancer for Cloud Run.
        External,
        /// Install internal load balancer for Cloud Run.
        Internal,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [LoadBalancerType::value] or
        /// [LoadBalancerType::name].
        UnknownValue(load_balancer_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod load_balancer_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl LoadBalancerType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::External => std::option::Option::Some(1),
                Self::Internal => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("LOAD_BALANCER_TYPE_UNSPECIFIED"),
                Self::External => std::option::Option::Some("LOAD_BALANCER_TYPE_EXTERNAL"),
                Self::Internal => std::option::Option::Some("LOAD_BALANCER_TYPE_INTERNAL"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for LoadBalancerType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for LoadBalancerType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for LoadBalancerType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::External,
                2 => Self::Internal,
                _ => Self::UnknownValue(load_balancer_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for LoadBalancerType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LOAD_BALANCER_TYPE_UNSPECIFIED" => Self::Unspecified,
                "LOAD_BALANCER_TYPE_EXTERNAL" => Self::External,
                "LOAD_BALANCER_TYPE_INTERNAL" => Self::Internal,
                _ => Self::UnknownValue(load_balancer_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for LoadBalancerType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::External => serializer.serialize_i32(1),
                Self::Internal => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for LoadBalancerType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<LoadBalancerType>::new(
                ".google.container.v1.CloudRunConfig.LoadBalancerType",
            ))
        }
    }
}

/// Configuration options for the Config Connector add-on.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ConfigConnectorConfig {
    /// Whether Cloud Connector is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ConfigConnectorConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ConfigConnectorConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ConfigConnectorConfig;
    /// let x = ConfigConnectorConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ConfigConnectorConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ConfigConnectorConfig"
    }
}

/// Configuration for the Compute Engine PD CSI driver.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcePersistentDiskCsiDriverConfig {
    /// Whether the Compute Engine PD CSI driver is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcePersistentDiskCsiDriverConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::GcePersistentDiskCsiDriverConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GcePersistentDiskCsiDriverConfig;
    /// let x = GcePersistentDiskCsiDriverConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for GcePersistentDiskCsiDriverConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GcePersistentDiskCsiDriverConfig"
    }
}

/// Configuration for the Filestore CSI driver.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcpFilestoreCsiDriverConfig {
    /// Whether the Filestore CSI driver is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcpFilestoreCsiDriverConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::GcpFilestoreCsiDriverConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GcpFilestoreCsiDriverConfig;
    /// let x = GcpFilestoreCsiDriverConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for GcpFilestoreCsiDriverConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GcpFilestoreCsiDriverConfig"
    }
}

/// Configuration for the Cloud Storage Fuse CSI driver.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcsFuseCsiDriverConfig {
    /// Whether the Cloud Storage Fuse CSI driver is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GcsFuseCsiDriverConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::GcsFuseCsiDriverConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GcsFuseCsiDriverConfig;
    /// let x = GcsFuseCsiDriverConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for GcsFuseCsiDriverConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GcsFuseCsiDriverConfig"
    }
}

/// Configuration for the Cloud Storage Parallelstore CSI driver.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ParallelstoreCsiDriverConfig {
    /// Whether the Cloud Storage Parallelstore CSI driver is enabled for this
    /// cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ParallelstoreCsiDriverConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ParallelstoreCsiDriverConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ParallelstoreCsiDriverConfig;
    /// let x = ParallelstoreCsiDriverConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ParallelstoreCsiDriverConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ParallelstoreCsiDriverConfig"
    }
}

/// Configuration for the High Scale Checkpointing.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct HighScaleCheckpointingConfig {
    /// Whether the High Scale Checkpointing is enabled for this
    /// cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl HighScaleCheckpointingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::HighScaleCheckpointingConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::HighScaleCheckpointingConfig;
    /// let x = HighScaleCheckpointingConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for HighScaleCheckpointingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.HighScaleCheckpointingConfig"
    }
}

/// Configuration for the Lustre CSI driver.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LustreCsiDriverConfig {
    /// Whether the Lustre CSI driver is enabled for this cluster.
    pub enabled: bool,

    /// If set to true, the Lustre CSI driver will install Lustre kernel modules
    /// using port 6988.
    /// This serves as a workaround for a port conflict with the
    /// gke-metadata-server. This field is required ONLY under the following
    /// conditions:
    ///
    /// 1. The GKE node version is older than 1.33.2-gke.4655000.
    /// 1. You're connecting to a Lustre instance that has the
    ///    'gke-support-enabled' flag.
    ///    Deprecated: This flag is no longer required as of GKE node version
    ///    1.33.2-gke.4655000, unless you are connecting to a Lustre instance
    ///    that has the `gke-support-enabled` flag.
    #[deprecated]
    pub enable_legacy_lustre_port: bool,

    /// When set to true, this disables multi-NIC support for the Lustre CSI
    /// driver.
    /// By default, GKE enables multi-NIC support, which allows the Lustre
    /// CSI driver to automatically detect and configure all suitable network
    /// interfaces on a node to maximize I/O performance for demanding workloads.
    pub disable_multi_nic: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LustreCsiDriverConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::LustreCsiDriverConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LustreCsiDriverConfig;
    /// let x = LustreCsiDriverConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [enable_legacy_lustre_port][crate::model::LustreCsiDriverConfig::enable_legacy_lustre_port].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LustreCsiDriverConfig;
    /// let x = LustreCsiDriverConfig::new().set_enable_legacy_lustre_port(true);
    /// ```
    #[deprecated]
    pub fn set_enable_legacy_lustre_port<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_legacy_lustre_port = v.into();
        self
    }

    /// Sets the value of [disable_multi_nic][crate::model::LustreCsiDriverConfig::disable_multi_nic].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LustreCsiDriverConfig;
    /// let x = LustreCsiDriverConfig::new().set_disable_multi_nic(true);
    /// ```
    pub fn set_disable_multi_nic<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disable_multi_nic = v.into();
        self
    }
}

impl wkt::message::Message for LustreCsiDriverConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LustreCsiDriverConfig"
    }
}

/// Configuration for the Slurm Operator.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SlurmOperatorConfig {
    /// When enabled, it runs a Slurm Operator that manages the set of compute pods
    /// for Slurm Cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SlurmOperatorConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::SlurmOperatorConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SlurmOperatorConfig;
    /// let x = SlurmOperatorConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for SlurmOperatorConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SlurmOperatorConfig"
    }
}

/// Configuration for the AgentSandbox addon.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AgentSandboxConfig {
    /// Optional. Whether AgentSandbox is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AgentSandboxConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::AgentSandboxConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AgentSandboxConfig;
    /// let x = AgentSandboxConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for AgentSandboxConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AgentSandboxConfig"
    }
}

/// Configuration for the GKE Node Readiness Controller.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeReadinessConfig {
    /// Optional. Whether the GKE Node Readiness Controller is enabled for this
    /// cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeReadinessConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::NodeReadinessConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeReadinessConfig;
    /// let x = NodeReadinessConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for NodeReadinessConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeReadinessConfig"
    }
}

/// Configuration for the Slice Controller.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SliceControllerConfig {
    /// Optional. Indicates whether Slice Controller is enabled in the cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SliceControllerConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::SliceControllerConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SliceControllerConfig;
    /// let x = SliceControllerConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for SliceControllerConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SliceControllerConfig"
    }
}

/// Configuration options for the Ray Operator add-on.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RayOperatorConfig {
    /// Whether the Ray Operator addon is enabled for this cluster.
    pub enabled: bool,

    /// Optional. Logging configuration for Ray clusters.
    pub ray_cluster_logging_config: std::option::Option<crate::model::RayClusterLoggingConfig>,

    /// Optional. Monitoring configuration for Ray clusters.
    pub ray_cluster_monitoring_config:
        std::option::Option<crate::model::RayClusterMonitoringConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RayOperatorConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::RayOperatorConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayOperatorConfig;
    /// let x = RayOperatorConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [ray_cluster_logging_config][crate::model::RayOperatorConfig::ray_cluster_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayOperatorConfig;
    /// use google_cloud_container_v1::model::RayClusterLoggingConfig;
    /// let x = RayOperatorConfig::new().set_ray_cluster_logging_config(RayClusterLoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_ray_cluster_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RayClusterLoggingConfig>,
    {
        self.ray_cluster_logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ray_cluster_logging_config][crate::model::RayOperatorConfig::ray_cluster_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayOperatorConfig;
    /// use google_cloud_container_v1::model::RayClusterLoggingConfig;
    /// let x = RayOperatorConfig::new().set_or_clear_ray_cluster_logging_config(Some(RayClusterLoggingConfig::default()/* use setters */));
    /// let x = RayOperatorConfig::new().set_or_clear_ray_cluster_logging_config(None::<RayClusterLoggingConfig>);
    /// ```
    pub fn set_or_clear_ray_cluster_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RayClusterLoggingConfig>,
    {
        self.ray_cluster_logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ray_cluster_monitoring_config][crate::model::RayOperatorConfig::ray_cluster_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayOperatorConfig;
    /// use google_cloud_container_v1::model::RayClusterMonitoringConfig;
    /// let x = RayOperatorConfig::new().set_ray_cluster_monitoring_config(RayClusterMonitoringConfig::default()/* use setters */);
    /// ```
    pub fn set_ray_cluster_monitoring_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RayClusterMonitoringConfig>,
    {
        self.ray_cluster_monitoring_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ray_cluster_monitoring_config][crate::model::RayOperatorConfig::ray_cluster_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayOperatorConfig;
    /// use google_cloud_container_v1::model::RayClusterMonitoringConfig;
    /// let x = RayOperatorConfig::new().set_or_clear_ray_cluster_monitoring_config(Some(RayClusterMonitoringConfig::default()/* use setters */));
    /// let x = RayOperatorConfig::new().set_or_clear_ray_cluster_monitoring_config(None::<RayClusterMonitoringConfig>);
    /// ```
    pub fn set_or_clear_ray_cluster_monitoring_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::RayClusterMonitoringConfig>,
    {
        self.ray_cluster_monitoring_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RayOperatorConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RayOperatorConfig"
    }
}

/// Configuration for the Backup for GKE Agent.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GkeBackupAgentConfig {
    /// Whether the Backup for GKE agent is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GkeBackupAgentConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::GkeBackupAgentConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GkeBackupAgentConfig;
    /// let x = GkeBackupAgentConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for GkeBackupAgentConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GkeBackupAgentConfig"
    }
}

/// Configuration for the Stateful HA add-on.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StatefulHAConfig {
    /// Whether the Stateful HA add-on is enabled for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl StatefulHAConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::StatefulHAConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StatefulHAConfig;
    /// let x = StatefulHAConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for StatefulHAConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.StatefulHAConfig"
    }
}

/// Configuration options for the master authorized networks feature. Enabled
/// master authorized networks will disallow all external traffic to access
/// Kubernetes master through HTTPS except traffic from the given CIDR blocks,
/// Google Compute Engine Public IPs and Google Prod IPs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MasterAuthorizedNetworksConfig {
    /// Whether or not master authorized networks is enabled.
    pub enabled: bool,

    /// cidr_blocks define up to 50 external networks that could access
    /// Kubernetes master through HTTPS.
    pub cidr_blocks: std::vec::Vec<crate::model::master_authorized_networks_config::CidrBlock>,

    /// Whether master is accessible via Google Compute Engine Public IP addresses.
    pub gcp_public_cidrs_access_enabled: std::option::Option<bool>,

    /// Whether master authorized networks is enforced on private endpoint or not.
    pub private_endpoint_enforcement_enabled: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MasterAuthorizedNetworksConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::MasterAuthorizedNetworksConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = MasterAuthorizedNetworksConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [cidr_blocks][crate::model::MasterAuthorizedNetworksConfig::cidr_blocks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// use google_cloud_container_v1::model::master_authorized_networks_config::CidrBlock;
    /// let x = MasterAuthorizedNetworksConfig::new()
    ///     .set_cidr_blocks([
    ///         CidrBlock::default()/* use setters */,
    ///         CidrBlock::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_cidr_blocks<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::master_authorized_networks_config::CidrBlock>,
    {
        use std::iter::Iterator;
        self.cidr_blocks = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [gcp_public_cidrs_access_enabled][crate::model::MasterAuthorizedNetworksConfig::gcp_public_cidrs_access_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = MasterAuthorizedNetworksConfig::new().set_gcp_public_cidrs_access_enabled(true);
    /// ```
    pub fn set_gcp_public_cidrs_access_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.gcp_public_cidrs_access_enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcp_public_cidrs_access_enabled][crate::model::MasterAuthorizedNetworksConfig::gcp_public_cidrs_access_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = MasterAuthorizedNetworksConfig::new().set_or_clear_gcp_public_cidrs_access_enabled(Some(false));
    /// let x = MasterAuthorizedNetworksConfig::new().set_or_clear_gcp_public_cidrs_access_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_gcp_public_cidrs_access_enabled<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.gcp_public_cidrs_access_enabled = v.map(|x| x.into());
        self
    }

    /// Sets the value of [private_endpoint_enforcement_enabled][crate::model::MasterAuthorizedNetworksConfig::private_endpoint_enforcement_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = MasterAuthorizedNetworksConfig::new().set_private_endpoint_enforcement_enabled(true);
    /// ```
    pub fn set_private_endpoint_enforcement_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.private_endpoint_enforcement_enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [private_endpoint_enforcement_enabled][crate::model::MasterAuthorizedNetworksConfig::private_endpoint_enforcement_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = MasterAuthorizedNetworksConfig::new().set_or_clear_private_endpoint_enforcement_enabled(Some(false));
    /// let x = MasterAuthorizedNetworksConfig::new().set_or_clear_private_endpoint_enforcement_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_private_endpoint_enforcement_enabled<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.private_endpoint_enforcement_enabled = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for MasterAuthorizedNetworksConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MasterAuthorizedNetworksConfig"
    }
}

/// Defines additional types related to [MasterAuthorizedNetworksConfig].
pub mod master_authorized_networks_config {
    #[allow(unused_imports)]
    use super::*;

    /// CidrBlock contains an optional name and one CIDR block.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct CidrBlock {
        /// display_name is an optional field for users to identify CIDR blocks.
        pub display_name: std::string::String,

        /// cidr_block must be specified in CIDR notation.
        pub cidr_block: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl CidrBlock {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [display_name][crate::model::master_authorized_networks_config::CidrBlock::display_name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::master_authorized_networks_config::CidrBlock;
        /// let x = CidrBlock::new().set_display_name("example");
        /// ```
        pub fn set_display_name<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.display_name = v.into();
            self
        }

        /// Sets the value of [cidr_block][crate::model::master_authorized_networks_config::CidrBlock::cidr_block].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::master_authorized_networks_config::CidrBlock;
        /// let x = CidrBlock::new().set_cidr_block("example");
        /// ```
        pub fn set_cidr_block<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.cidr_block = v.into();
            self
        }
    }

    impl wkt::message::Message for CidrBlock {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.MasterAuthorizedNetworksConfig.CidrBlock"
        }
    }
}

/// Configuration for the legacy Attribute Based Access Control authorization
/// mode.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LegacyAbac {
    /// Whether the ABAC authorizer is enabled for this cluster. When enabled,
    /// identities in the system, including service accounts, nodes, and
    /// controllers, will have statically granted permissions beyond those
    /// provided by the RBAC configuration or IAM.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LegacyAbac {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::LegacyAbac::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LegacyAbac;
    /// let x = LegacyAbac::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for LegacyAbac {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LegacyAbac"
    }
}

/// Configuration options for the NetworkPolicy feature.
/// <https://kubernetes.io/docs/concepts/services-networking/networkpolicies/>
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkPolicy {
    /// The selected network policy provider.
    pub provider: crate::model::network_policy::Provider,

    /// Whether network policy is enabled on the cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NetworkPolicy {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [provider][crate::model::NetworkPolicy::provider].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkPolicy;
    /// use google_cloud_container_v1::model::network_policy::Provider;
    /// let x0 = NetworkPolicy::new().set_provider(Provider::Calico);
    /// ```
    pub fn set_provider<T: std::convert::Into<crate::model::network_policy::Provider>>(
        mut self,
        v: T,
    ) -> Self {
        self.provider = v.into();
        self
    }

    /// Sets the value of [enabled][crate::model::NetworkPolicy::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkPolicy;
    /// let x = NetworkPolicy::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for NetworkPolicy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NetworkPolicy"
    }
}

/// Defines additional types related to [NetworkPolicy].
pub mod network_policy {
    #[allow(unused_imports)]
    use super::*;

    /// Allowed Network Policy providers.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Provider {
        /// Not set
        Unspecified,
        /// Tigera (Calico Felix).
        Calico,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Provider::value] or
        /// [Provider::name].
        UnknownValue(provider::UnknownValue),
    }

    #[doc(hidden)]
    pub mod provider {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Provider {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Calico => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("PROVIDER_UNSPECIFIED"),
                Self::Calico => std::option::Option::Some("CALICO"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Provider {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Provider {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Provider {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Calico,
                _ => Self::UnknownValue(provider::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Provider {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PROVIDER_UNSPECIFIED" => Self::Unspecified,
                "CALICO" => Self::Calico,
                _ => Self::UnknownValue(provider::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Provider {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Calico => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Provider {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Provider>::new(
                ".google.container.v1.NetworkPolicy.Provider",
            ))
        }
    }
}

/// Configuration for Binary Authorization.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BinaryAuthorization {
    /// This field is deprecated. Leave this unset and instead configure
    /// BinaryAuthorization using evaluation_mode. If evaluation_mode is set to
    /// anything other than EVALUATION_MODE_UNSPECIFIED, this field is ignored.
    #[deprecated]
    pub enabled: bool,

    /// Mode of operation for binauthz policy evaluation. If unspecified, defaults
    /// to DISABLED.
    pub evaluation_mode: crate::model::binary_authorization::EvaluationMode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BinaryAuthorization {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::BinaryAuthorization::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BinaryAuthorization;
    /// let x = BinaryAuthorization::new().set_enabled(true);
    /// ```
    #[deprecated]
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [evaluation_mode][crate::model::BinaryAuthorization::evaluation_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BinaryAuthorization;
    /// use google_cloud_container_v1::model::binary_authorization::EvaluationMode;
    /// let x0 = BinaryAuthorization::new().set_evaluation_mode(EvaluationMode::Disabled);
    /// let x1 = BinaryAuthorization::new().set_evaluation_mode(EvaluationMode::ProjectSingletonPolicyEnforce);
    /// ```
    pub fn set_evaluation_mode<
        T: std::convert::Into<crate::model::binary_authorization::EvaluationMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.evaluation_mode = v.into();
        self
    }
}

impl wkt::message::Message for BinaryAuthorization {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.BinaryAuthorization"
    }
}

/// Defines additional types related to [BinaryAuthorization].
pub mod binary_authorization {
    #[allow(unused_imports)]
    use super::*;

    /// Binary Authorization mode of operation.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EvaluationMode {
        /// Default value
        Unspecified,
        /// Disable BinaryAuthorization
        Disabled,
        /// Enforce Kubernetes admission requests with BinaryAuthorization using the
        /// project's singleton policy. This is equivalent to setting the
        /// enabled boolean to true.
        ProjectSingletonPolicyEnforce,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EvaluationMode::value] or
        /// [EvaluationMode::name].
        UnknownValue(evaluation_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod evaluation_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EvaluationMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::ProjectSingletonPolicyEnforce => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EVALUATION_MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::ProjectSingletonPolicyEnforce => {
                    std::option::Option::Some("PROJECT_SINGLETON_POLICY_ENFORCE")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EvaluationMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EvaluationMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EvaluationMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                2 => Self::ProjectSingletonPolicyEnforce,
                _ => Self::UnknownValue(evaluation_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EvaluationMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EVALUATION_MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "PROJECT_SINGLETON_POLICY_ENFORCE" => Self::ProjectSingletonPolicyEnforce,
                _ => Self::UnknownValue(evaluation_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EvaluationMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::ProjectSingletonPolicyEnforce => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EvaluationMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EvaluationMode>::new(
                ".google.container.v1.BinaryAuthorization.EvaluationMode",
            ))
        }
    }
}

/// [PRIVATE FIELD]
/// Config for pod CIDR size overprovisioning.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PodCIDROverprovisionConfig {
    /// Whether Pod CIDR overprovisioning is disabled.
    /// Note: Pod CIDR overprovisioning is enabled by default.
    pub disable: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PodCIDROverprovisionConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disable][crate::model::PodCIDROverprovisionConfig::disable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PodCIDROverprovisionConfig;
    /// let x = PodCIDROverprovisionConfig::new().set_disable(true);
    /// ```
    pub fn set_disable<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disable = v.into();
        self
    }
}

impl wkt::message::Message for PodCIDROverprovisionConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PodCIDROverprovisionConfig"
    }
}

/// Configuration for controlling how IPs are allocated in the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct IPAllocationPolicy {
    /// Whether alias IPs will be used for pod IPs in the cluster.
    /// This is used in conjunction with use_routes. It cannot
    /// be true if use_routes is true. If both use_ip_aliases and use_routes are
    /// false, then the server picks the default IP allocation mode
    pub use_ip_aliases: bool,

    /// Whether a new subnetwork will be created automatically for the cluster.
    ///
    /// This field is only applicable when `use_ip_aliases` is true.
    pub create_subnetwork: bool,

    /// A custom subnetwork name to be used if `create_subnetwork` is true.  If
    /// this field is empty, then an automatic name will be chosen for the new
    /// subnetwork.
    pub subnetwork_name: std::string::String,

    /// This field is deprecated, use cluster_ipv4_cidr_block.
    #[deprecated]
    pub cluster_ipv4_cidr: std::string::String,

    /// This field is deprecated, use node_ipv4_cidr_block.
    #[deprecated]
    pub node_ipv4_cidr: std::string::String,

    /// This field is deprecated, use services_ipv4_cidr_block.
    #[deprecated]
    pub services_ipv4_cidr: std::string::String,

    /// The name of the secondary range to be used for the cluster CIDR
    /// block.  The secondary range will be used for pod IP
    /// addresses. This must be an existing secondary range associated
    /// with the cluster subnetwork.
    ///
    /// This field is only applicable with use_ip_aliases is true and
    /// create_subnetwork is false.
    pub cluster_secondary_range_name: std::string::String,

    /// The name of the secondary range to be used as for the services
    /// CIDR block.  The secondary range will be used for service
    /// ClusterIPs. This must be an existing secondary range associated
    /// with the cluster subnetwork.
    ///
    /// This field is only applicable with use_ip_aliases is true and
    /// create_subnetwork is false.
    pub services_secondary_range_name: std::string::String,

    /// The IP address range for the cluster pod IPs. If this field is set, then
    /// `cluster.cluster_ipv4_cidr` must be left blank.
    ///
    /// This field is only applicable when `use_ip_aliases` is true.
    ///
    /// Set to blank to have a range chosen with the default size.
    ///
    /// Set to /netmask (e.g. `/14`) to have a range chosen with a specific
    /// netmask.
    ///
    /// Set to a
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g.
    /// `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range
    /// to use.
    pub cluster_ipv4_cidr_block: std::string::String,

    /// The IP address range of the instance IPs in this cluster.
    ///
    /// This is applicable only if `create_subnetwork` is true.
    ///
    /// Set to blank to have a range chosen with the default size.
    ///
    /// Set to /netmask (e.g. `/14`) to have a range chosen with a specific
    /// netmask.
    ///
    /// Set to a
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g.
    /// `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range
    /// to use.
    pub node_ipv4_cidr_block: std::string::String,

    /// The IP address range of the services IPs in this cluster. If blank, a range
    /// will be automatically chosen with the default size.
    ///
    /// This field is only applicable when `use_ip_aliases` is true.
    ///
    /// Set to blank to have a range chosen with the default size.
    ///
    /// Set to /netmask (e.g. `/14`) to have a range chosen with a specific
    /// netmask.
    ///
    /// Set to a
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g.
    /// `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range
    /// to use.
    pub services_ipv4_cidr_block: std::string::String,

    /// The IP address range of the Cloud TPUs in this cluster. If unspecified, a
    /// range will be automatically chosen with the default size.
    ///
    /// This field is only applicable when `use_ip_aliases` is true.
    ///
    /// If unspecified, the range will use the default size.
    ///
    /// Set to /netmask (e.g. `/14`) to have a range chosen with a specific
    /// netmask.
    ///
    /// Set to a
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g.
    /// `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range
    /// to use.
    ///
    /// This field is deprecated due to the deprecation of 2VM TPU. The end of life
    /// date for 2VM TPU is 2025-04-25.
    #[deprecated]
    pub tpu_ipv4_cidr_block: std::string::String,

    /// Whether routes will be used for pod IPs in the cluster.
    /// This is used in conjunction with use_ip_aliases. It cannot be true if
    /// use_ip_aliases is true. If both use_ip_aliases and use_routes are false,
    /// then the server picks the default IP allocation mode
    pub use_routes: bool,

    /// The IP stack type of the cluster
    pub stack_type: crate::model::StackType,

    /// The ipv6 access type (internal or external) when create_subnetwork is true
    pub ipv6_access_type: crate::model::IPv6AccessType,

    /// [PRIVATE FIELD]
    /// Pod CIDR size overprovisioning config for the cluster.
    ///
    /// Pod CIDR size per node depends on max_pods_per_node. By default, the value
    /// of max_pods_per_node is doubled and then rounded off to next power of 2 to
    /// get the size of pod CIDR block per node.
    /// Example: max_pods_per_node of 30 would result in 64 IPs (/26).
    ///
    /// This config can disable the doubling of IPs (we still round off to next
    /// power of 2)
    /// Example: max_pods_per_node of 30 will result in 32 IPs (/27) when
    /// overprovisioning is disabled.
    pub pod_cidr_overprovision_config:
        std::option::Option<crate::model::PodCIDROverprovisionConfig>,

    /// Output only. The subnet's IPv6 CIDR block used by nodes and pods.
    pub subnet_ipv6_cidr_block: std::string::String,

    /// Output only. The services IPv6 CIDR block for the cluster.
    pub services_ipv6_cidr_block: std::string::String,

    /// Output only. The additional pod ranges that are added to the cluster.
    /// These pod ranges can be used by new node pools to allocate pod IPs
    /// automatically. Once the range is removed it will not show up in
    /// IPAllocationPolicy.
    pub additional_pod_ranges_config: std::option::Option<crate::model::AdditionalPodRangesConfig>,

    /// Output only. The utilization of the cluster default IPv4 range for the
    /// pod. The ratio is Usage/[Total number of IPs in the secondary range],
    /// Usage=numNodes*numZones*podIPsPerNode.
    pub default_pod_ipv4_range_utilization: f64,

    /// Output only. The additional IP ranges that are added to the cluster.
    /// These IP ranges can be used by new node pools to allocate node and pod IPs
    /// automatically.
    /// Each AdditionalIPRangesConfig corresponds to a single subnetwork.
    /// Once a range is removed it will not show up in IPAllocationPolicy.
    pub additional_ip_ranges_configs: std::vec::Vec<crate::model::AdditionalIPRangesConfig>,

    /// Optional. AutoIpamConfig contains all information related to Auto IPAM
    pub auto_ipam_config: std::option::Option<crate::model::AutoIpamConfig>,

    /// Cluster-level network tier configuration is used to determine the default
    /// network tier for external IP addresses on cluster resources, such as node
    /// pools and load balancers.
    pub network_tier_config: std::option::Option<crate::model::NetworkTierConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl IPAllocationPolicy {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [use_ip_aliases][crate::model::IPAllocationPolicy::use_ip_aliases].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_use_ip_aliases(true);
    /// ```
    pub fn set_use_ip_aliases<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.use_ip_aliases = v.into();
        self
    }

    /// Sets the value of [create_subnetwork][crate::model::IPAllocationPolicy::create_subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_create_subnetwork(true);
    /// ```
    pub fn set_create_subnetwork<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.create_subnetwork = v.into();
        self
    }

    /// Sets the value of [subnetwork_name][crate::model::IPAllocationPolicy::subnetwork_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_subnetwork_name("example");
    /// ```
    pub fn set_subnetwork_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork_name = v.into();
        self
    }

    /// Sets the value of [cluster_ipv4_cidr][crate::model::IPAllocationPolicy::cluster_ipv4_cidr].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_cluster_ipv4_cidr("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_ipv4_cidr<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_ipv4_cidr = v.into();
        self
    }

    /// Sets the value of [node_ipv4_cidr][crate::model::IPAllocationPolicy::node_ipv4_cidr].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_node_ipv4_cidr("example");
    /// ```
    #[deprecated]
    pub fn set_node_ipv4_cidr<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_ipv4_cidr = v.into();
        self
    }

    /// Sets the value of [services_ipv4_cidr][crate::model::IPAllocationPolicy::services_ipv4_cidr].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_services_ipv4_cidr("example");
    /// ```
    #[deprecated]
    pub fn set_services_ipv4_cidr<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.services_ipv4_cidr = v.into();
        self
    }

    /// Sets the value of [cluster_secondary_range_name][crate::model::IPAllocationPolicy::cluster_secondary_range_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_cluster_secondary_range_name("example");
    /// ```
    pub fn set_cluster_secondary_range_name<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_secondary_range_name = v.into();
        self
    }

    /// Sets the value of [services_secondary_range_name][crate::model::IPAllocationPolicy::services_secondary_range_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_services_secondary_range_name("example");
    /// ```
    pub fn set_services_secondary_range_name<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.services_secondary_range_name = v.into();
        self
    }

    /// Sets the value of [cluster_ipv4_cidr_block][crate::model::IPAllocationPolicy::cluster_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_cluster_ipv4_cidr_block("example");
    /// ```
    pub fn set_cluster_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [node_ipv4_cidr_block][crate::model::IPAllocationPolicy::node_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_node_ipv4_cidr_block("example");
    /// ```
    pub fn set_node_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.node_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [services_ipv4_cidr_block][crate::model::IPAllocationPolicy::services_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_services_ipv4_cidr_block("example");
    /// ```
    pub fn set_services_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.services_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [tpu_ipv4_cidr_block][crate::model::IPAllocationPolicy::tpu_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_tpu_ipv4_cidr_block("example");
    /// ```
    #[deprecated]
    pub fn set_tpu_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.tpu_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [use_routes][crate::model::IPAllocationPolicy::use_routes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_use_routes(true);
    /// ```
    pub fn set_use_routes<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.use_routes = v.into();
        self
    }

    /// Sets the value of [stack_type][crate::model::IPAllocationPolicy::stack_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::StackType;
    /// let x0 = IPAllocationPolicy::new().set_stack_type(StackType::Ipv4);
    /// let x1 = IPAllocationPolicy::new().set_stack_type(StackType::Ipv4Ipv6);
    /// ```
    pub fn set_stack_type<T: std::convert::Into<crate::model::StackType>>(mut self, v: T) -> Self {
        self.stack_type = v.into();
        self
    }

    /// Sets the value of [ipv6_access_type][crate::model::IPAllocationPolicy::ipv6_access_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::IPv6AccessType;
    /// let x0 = IPAllocationPolicy::new().set_ipv6_access_type(IPv6AccessType::Internal);
    /// let x1 = IPAllocationPolicy::new().set_ipv6_access_type(IPv6AccessType::External);
    /// ```
    pub fn set_ipv6_access_type<T: std::convert::Into<crate::model::IPv6AccessType>>(
        mut self,
        v: T,
    ) -> Self {
        self.ipv6_access_type = v.into();
        self
    }

    /// Sets the value of [pod_cidr_overprovision_config][crate::model::IPAllocationPolicy::pod_cidr_overprovision_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::PodCIDROverprovisionConfig;
    /// let x = IPAllocationPolicy::new().set_pod_cidr_overprovision_config(PodCIDROverprovisionConfig::default()/* use setters */);
    /// ```
    pub fn set_pod_cidr_overprovision_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PodCIDROverprovisionConfig>,
    {
        self.pod_cidr_overprovision_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pod_cidr_overprovision_config][crate::model::IPAllocationPolicy::pod_cidr_overprovision_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::PodCIDROverprovisionConfig;
    /// let x = IPAllocationPolicy::new().set_or_clear_pod_cidr_overprovision_config(Some(PodCIDROverprovisionConfig::default()/* use setters */));
    /// let x = IPAllocationPolicy::new().set_or_clear_pod_cidr_overprovision_config(None::<PodCIDROverprovisionConfig>);
    /// ```
    pub fn set_or_clear_pod_cidr_overprovision_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::PodCIDROverprovisionConfig>,
    {
        self.pod_cidr_overprovision_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [subnet_ipv6_cidr_block][crate::model::IPAllocationPolicy::subnet_ipv6_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_subnet_ipv6_cidr_block("example");
    /// ```
    pub fn set_subnet_ipv6_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.subnet_ipv6_cidr_block = v.into();
        self
    }

    /// Sets the value of [services_ipv6_cidr_block][crate::model::IPAllocationPolicy::services_ipv6_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_services_ipv6_cidr_block("example");
    /// ```
    pub fn set_services_ipv6_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.services_ipv6_cidr_block = v.into();
        self
    }

    /// Sets the value of [additional_pod_ranges_config][crate::model::IPAllocationPolicy::additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = IPAllocationPolicy::new().set_additional_pod_ranges_config(AdditionalPodRangesConfig::default()/* use setters */);
    /// ```
    pub fn set_additional_pod_ranges_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.additional_pod_ranges_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [additional_pod_ranges_config][crate::model::IPAllocationPolicy::additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = IPAllocationPolicy::new().set_or_clear_additional_pod_ranges_config(Some(AdditionalPodRangesConfig::default()/* use setters */));
    /// let x = IPAllocationPolicy::new().set_or_clear_additional_pod_ranges_config(None::<AdditionalPodRangesConfig>);
    /// ```
    pub fn set_or_clear_additional_pod_ranges_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.additional_pod_ranges_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [default_pod_ipv4_range_utilization][crate::model::IPAllocationPolicy::default_pod_ipv4_range_utilization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = IPAllocationPolicy::new().set_default_pod_ipv4_range_utilization(42.0);
    /// ```
    pub fn set_default_pod_ipv4_range_utilization<T: std::convert::Into<f64>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_pod_ipv4_range_utilization = v.into();
        self
    }

    /// Sets the value of [additional_ip_ranges_configs][crate::model::IPAllocationPolicy::additional_ip_ranges_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::AdditionalIPRangesConfig;
    /// let x = IPAllocationPolicy::new()
    ///     .set_additional_ip_ranges_configs([
    ///         AdditionalIPRangesConfig::default()/* use setters */,
    ///         AdditionalIPRangesConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_additional_ip_ranges_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AdditionalIPRangesConfig>,
    {
        use std::iter::Iterator;
        self.additional_ip_ranges_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [auto_ipam_config][crate::model::IPAllocationPolicy::auto_ipam_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = IPAllocationPolicy::new().set_auto_ipam_config(AutoIpamConfig::default()/* use setters */);
    /// ```
    pub fn set_auto_ipam_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AutoIpamConfig>,
    {
        self.auto_ipam_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [auto_ipam_config][crate::model::IPAllocationPolicy::auto_ipam_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = IPAllocationPolicy::new().set_or_clear_auto_ipam_config(Some(AutoIpamConfig::default()/* use setters */));
    /// let x = IPAllocationPolicy::new().set_or_clear_auto_ipam_config(None::<AutoIpamConfig>);
    /// ```
    pub fn set_or_clear_auto_ipam_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AutoIpamConfig>,
    {
        self.auto_ipam_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [network_tier_config][crate::model::IPAllocationPolicy::network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = IPAllocationPolicy::new().set_network_tier_config(NetworkTierConfig::default()/* use setters */);
    /// ```
    pub fn set_network_tier_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.network_tier_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_tier_config][crate::model::IPAllocationPolicy::network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IPAllocationPolicy;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = IPAllocationPolicy::new().set_or_clear_network_tier_config(Some(NetworkTierConfig::default()/* use setters */));
    /// let x = IPAllocationPolicy::new().set_or_clear_network_tier_config(None::<NetworkTierConfig>);
    /// ```
    pub fn set_or_clear_network_tier_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.network_tier_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for IPAllocationPolicy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.IPAllocationPolicy"
    }
}

/// A Google Kubernetes Engine cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Cluster {
    /// The name of this cluster. The name must be unique within this project
    /// and location (e.g. zone or region), and can be up to 40 characters with
    /// the following restrictions:
    ///
    /// * Lowercase letters, numbers, and hyphens only.
    /// * Must start with a letter.
    /// * Must end with a number or a letter.
    pub name: std::string::String,

    /// An optional description of this cluster.
    pub description: std::string::String,

    /// The number of nodes to create in this cluster. You must ensure that your
    /// Compute Engine [resource
    /// quota](https://cloud.google.com/compute/quotas)
    /// is sufficient for this number of instances. You must also have available
    /// firewall and routes quota.
    /// For requests, this field should only be used in lieu of a
    /// "node_pool" object, since this configuration (along with the
    /// "node_config") will be used to create a "NodePool" object with an
    /// auto-generated name. Do not use this and a node_pool at the same time.
    ///
    /// This field is deprecated, use node_pool.initial_node_count instead.
    #[deprecated]
    pub initial_node_count: i32,

    /// Parameters used in creating the cluster's nodes.
    /// For requests, this field should only be used in lieu of a
    /// "node_pool" object, since this configuration (along with the
    /// "initial_node_count") will be used to create a "NodePool" object with an
    /// auto-generated name. Do not use this and a node_pool at the same time.
    /// For responses, this field will be populated with the node configuration of
    /// the first node pool. (For configuration of each node pool, see
    /// `node_pool.config`)
    ///
    /// If unspecified, the defaults are used.
    /// This field is deprecated, use node_pool.config instead.
    #[deprecated]
    pub node_config: std::option::Option<crate::model::NodeConfig>,

    /// The authentication information for accessing the master endpoint.
    /// If unspecified, the defaults are used:
    /// For clusters before v1.12, if master_auth is unspecified, `username` will
    /// be set to "admin", a random password will be generated, and a client
    /// certificate will be issued.
    pub master_auth: std::option::Option<crate::model::MasterAuth>,

    /// The logging service the cluster should use to write logs.
    /// Currently available options:
    ///
    /// * `logging.googleapis.com/kubernetes` - The Cloud Logging
    ///   service with a Kubernetes-native resource model
    /// * `logging.googleapis.com` - The legacy Cloud Logging service (no longer
    ///   available as of GKE 1.15).
    /// * `none` - no logs will be exported from the cluster.
    ///
    /// If left as an empty string,`logging.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `logging.googleapis.com` for earlier versions.
    pub logging_service: std::string::String,

    /// The monitoring service the cluster should use to write metrics.
    /// Currently available options:
    ///
    /// * `monitoring.googleapis.com/kubernetes` - The Cloud Monitoring
    ///   service with a Kubernetes-native resource model
    /// * `monitoring.googleapis.com` - The legacy Cloud Monitoring service (no
    ///   longer available as of GKE 1.15).
    /// * `none` - No metrics will be exported from the cluster.
    ///
    /// If left as an empty string,`monitoring.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `monitoring.googleapis.com` for earlier versions.
    pub monitoring_service: std::string::String,

    /// The name of the Google Compute Engine
    /// [network](https://cloud.google.com/compute/docs/networks-and-firewalls#networks)
    /// to which the cluster is connected. If left unspecified, the `default`
    /// network will be used.
    pub network: std::string::String,

    /// The IP address range of the container pods in this cluster, in
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `10.96.0.0/14`). Leave blank to have
    /// one automatically chosen or specify a `/14` block in `10.0.0.0/8`.
    pub cluster_ipv4_cidr: std::string::String,

    /// Configurations for the various addons available to run in the cluster.
    pub addons_config: std::option::Option<crate::model::AddonsConfig>,

    /// The name of the Google Compute Engine
    /// [subnetwork](https://cloud.google.com/compute/docs/subnetworks)
    /// to which the cluster is connected.
    pub subnetwork: std::string::String,

    /// The node pools associated with this cluster.
    /// This field should not be set if "node_config" or "initial_node_count" are
    /// specified.
    pub node_pools: std::vec::Vec<crate::model::NodePool>,

    /// The list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster's nodes should be located.
    ///
    /// This field provides a default value if
    /// [NodePool.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters.nodePools#NodePool.FIELDS.locations)
    /// are not specified during node pool creation.
    ///
    /// Warning: changing cluster locations will update the
    /// [NodePool.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters.nodePools#NodePool.FIELDS.locations)
    /// of all node pools and will result in nodes being added and/or removed.
    pub locations: std::vec::Vec<std::string::String>,

    /// Kubernetes alpha features are enabled on this cluster. This includes alpha
    /// API groups (e.g. v1alpha1) and features that may not be production ready in
    /// the kubernetes version of the master and nodes.
    /// The cluster has no SLA for uptime and master/node upgrades are disabled.
    /// Alpha enabled clusters are automatically deleted thirty days after
    /// creation.
    pub enable_kubernetes_alpha: bool,

    /// The list of user specified Kubernetes feature gates.
    /// Each string represents the activation status of a feature gate (e.g.
    /// "featureX=true" or "featureX=false")
    pub alpha_cluster_feature_gates: std::vec::Vec<std::string::String>,

    /// The resource labels for the cluster to use to annotate any related
    /// Google Compute Engine resources.
    pub resource_labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// The fingerprint of the set of labels for this cluster.
    pub label_fingerprint: std::string::String,

    /// Configuration for the legacy ABAC authorization mode.
    pub legacy_abac: std::option::Option<crate::model::LegacyAbac>,

    /// Configuration options for the NetworkPolicy feature.
    pub network_policy: std::option::Option<crate::model::NetworkPolicy>,

    /// Configuration for cluster IP allocation.
    pub ip_allocation_policy: std::option::Option<crate::model::IPAllocationPolicy>,

    /// The configuration options for master authorized networks feature.
    ///
    /// Deprecated: Use
    /// [ControlPlaneEndpointsConfig.IPEndpointsConfig.authorized_networks_config][google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.authorized_networks_config]
    /// instead.
    ///
    /// [google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig.authorized_networks_config]: crate::model::control_plane_endpoints_config::IPEndpointsConfig::authorized_networks_config
    #[deprecated]
    pub master_authorized_networks_config:
        std::option::Option<crate::model::MasterAuthorizedNetworksConfig>,

    /// Configure the maintenance policy for this cluster.
    pub maintenance_policy: std::option::Option<crate::model::MaintenancePolicy>,

    /// Configuration for Binary Authorization.
    pub binary_authorization: std::option::Option<crate::model::BinaryAuthorization>,

    /// Cluster-level autoscaling configuration.
    pub autoscaling: std::option::Option<crate::model::ClusterAutoscaling>,

    /// Configuration for cluster networking.
    pub network_config: std::option::Option<crate::model::NetworkConfig>,

    /// The default constraint on the maximum number of pods that can be run
    /// simultaneously on a node in the node pool of this cluster. Only honored
    /// if cluster created with IP Alias support.
    pub default_max_pods_constraint: std::option::Option<crate::model::MaxPodsConstraint>,

    /// Configuration for exporting resource usages. Resource usage export is
    /// disabled when this config is unspecified.
    pub resource_usage_export_config: std::option::Option<crate::model::ResourceUsageExportConfig>,

    /// Configuration controlling RBAC group membership information.
    pub authenticator_groups_config: std::option::Option<crate::model::AuthenticatorGroupsConfig>,

    /// Configuration for private cluster.
    pub private_cluster_config: std::option::Option<crate::model::PrivateClusterConfig>,

    /// Configuration of etcd encryption.
    pub database_encryption: std::option::Option<crate::model::DatabaseEncryption>,

    /// Cluster-level Vertical Pod Autoscaling configuration.
    pub vertical_pod_autoscaling: std::option::Option<crate::model::VerticalPodAutoscaling>,

    /// Shielded Nodes configuration.
    pub shielded_nodes: std::option::Option<crate::model::ShieldedNodes>,

    /// Release channel configuration. If left unspecified on cluster creation and
    /// a version is specified, the cluster is enrolled in the most mature release
    /// channel where the version is available (first checking STABLE, then
    /// REGULAR, and finally RAPID). Otherwise, if no release channel
    /// configuration and no version is specified, the cluster is enrolled in the
    /// REGULAR channel with its default version.
    pub release_channel: std::option::Option<crate::model::ReleaseChannel>,

    /// Configuration for the use of Kubernetes Service Accounts in IAM policies.
    pub workload_identity_config: std::option::Option<crate::model::WorkloadIdentityConfig>,

    /// Configuration for issuance of mTLS keys and certificates to Kubernetes
    /// pods.
    pub mesh_certificates: std::option::Option<crate::model::MeshCertificates>,

    /// Configuration for the fine-grained cost management feature.
    pub cost_management_config: std::option::Option<crate::model::CostManagementConfig>,

    /// Notification configuration of the cluster.
    pub notification_config: std::option::Option<crate::model::NotificationConfig>,

    /// Configuration of Confidential Nodes.
    /// All the nodes in the cluster will be Confidential VM once enabled.
    pub confidential_nodes: std::option::Option<crate::model::ConfidentialNodes>,

    /// Configuration for Identity Service component.
    pub identity_service_config: std::option::Option<crate::model::IdentityServiceConfig>,

    /// Output only. Server-defined URL for the resource.
    pub self_link: std::string::String,

    /// Output only. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field is deprecated, use location
    /// instead.
    #[deprecated]
    pub zone: std::string::String,

    /// Output only. The IP address of this cluster's master endpoint.
    /// The endpoint can be accessed from the internet at
    /// `https://username:password@endpoint/`.
    ///
    /// See the `masterAuth` property of this resource for username and
    /// password information.
    pub endpoint: std::string::String,

    /// The initial Kubernetes version for this cluster.  Valid versions are those
    /// found in validMasterVersions returned by getServerConfig.  The version can
    /// be upgraded over time; such upgrades are reflected in
    /// currentMasterVersion and currentNodeVersion.
    ///
    /// Users may specify either explicit versions offered by
    /// Kubernetes Engine or version aliases, which have the following behavior:
    ///
    /// - "latest": picks the highest valid Kubernetes version
    /// - "1.X": picks the highest valid patch+gke.N patch in the 1.X version
    /// - "1.X.Y": picks the highest valid gke.N patch in the 1.X.Y version
    /// - "1.X.Y-gke.N": picks an explicit Kubernetes version
    /// - "","-": picks the default Kubernetes version
    pub initial_cluster_version: std::string::String,

    /// Output only. The current software version of the master endpoint.
    pub current_master_version: std::string::String,

    /// Output only. Deprecated, use
    /// [NodePools.version](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters.nodePools)
    /// instead. The current version of the node software components. If they are
    /// currently at multiple versions because they're in the process of being
    /// upgraded, this reflects the minimum version of all nodes.
    #[deprecated]
    pub current_node_version: std::string::String,

    /// Output only. The time the cluster was created, in
    /// [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
    pub create_time: std::string::String,

    /// Output only. The current status of this cluster.
    pub status: crate::model::cluster::Status,

    /// Output only. Deprecated. Use conditions instead.
    /// Additional information about the current status of this
    /// cluster, if available.
    #[deprecated]
    pub status_message: std::string::String,

    /// Output only. The size of the address space on each node for hosting
    /// containers. This is provisioned from within the `container_ipv4_cidr`
    /// range. This field will only be set when cluster is in route-based network
    /// mode.
    pub node_ipv4_cidr_size: i32,

    /// Output only. The IP address range of the Kubernetes services in
    /// this cluster, in
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `1.2.3.4/29`). Service addresses are
    /// typically put in the last `/16` from the container CIDR.
    pub services_ipv4_cidr: std::string::String,

    /// Output only. Deprecated. Use node_pools.instance_group_urls.
    #[deprecated]
    pub instance_group_urls: std::vec::Vec<std::string::String>,

    /// Output only. The number of nodes currently in the cluster. Deprecated.
    /// Call Kubernetes API directly to retrieve node information.
    #[deprecated]
    pub current_node_count: i32,

    /// Output only. The time the cluster will be automatically
    /// deleted in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
    pub expire_time: std::string::String,

    /// Output only. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/regions-zones/regions-zones#available)
    /// or
    /// [region](https://cloud.google.com/compute/docs/regions-zones/regions-zones#available)
    /// in which the cluster resides.
    pub location: std::string::String,

    /// Enable the ability to use Cloud TPUs in this cluster.
    /// This field is deprecated due to the deprecation of 2VM TPU. The end of life
    /// date for 2VM TPU is 2025-04-25.
    #[deprecated]
    pub enable_tpu: bool,

    /// Output only. The IP address range of the Cloud TPUs in this cluster, in
    /// [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing)
    /// notation (e.g. `1.2.3.4/29`).
    /// This field is deprecated due to the deprecation of 2VM TPU. The end of life
    /// date for 2VM TPU is 2025-04-25.
    #[deprecated]
    pub tpu_ipv4_cidr_block: std::string::String,

    /// Which conditions caused the current cluster state.
    pub conditions: std::vec::Vec<crate::model::StatusCondition>,

    /// Autopilot configuration for the cluster.
    pub autopilot: std::option::Option<crate::model::Autopilot>,

    /// Output only. Unique id for the cluster.
    pub id: std::string::String,

    /// Default NodePool settings for the entire cluster. These settings are
    /// overridden if specified on the specific NodePool object.
    pub node_pool_defaults: std::option::Option<crate::model::NodePoolDefaults>,

    /// Logging configuration for the cluster.
    pub logging_config: std::option::Option<crate::model::LoggingConfig>,

    /// Monitoring configuration for the cluster.
    pub monitoring_config: std::option::Option<crate::model::MonitoringConfig>,

    /// Node pool configs that apply to all auto-provisioned node pools
    /// in autopilot clusters and node auto-provisioning enabled clusters.
    pub node_pool_auto_config: std::option::Option<crate::model::NodePoolAutoConfig>,

    /// The config for pod autoscaling.
    pub pod_autoscaling: std::option::Option<crate::model::PodAutoscaling>,

    /// This checksum is computed by the server based on the value of cluster
    /// fields, and may be sent on update requests to ensure the client has an
    /// up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Fleet information for the cluster.
    pub fleet: std::option::Option<crate::model::Fleet>,

    /// Optional. Enable/Disable Security Posture API features for the cluster.
    pub security_posture_config: std::option::Option<crate::model::SecurityPostureConfig>,

    /// Configuration for all cluster's control plane endpoints.
    pub control_plane_endpoints_config:
        std::option::Option<crate::model::ControlPlaneEndpointsConfig>,

    /// Beta APIs Config
    pub enable_k8s_beta_apis: std::option::Option<crate::model::K8sBetaAPIConfig>,

    /// GKE Enterprise Configuration.
    ///
    /// Deprecated: GKE Enterprise features are now available without an Enterprise
    /// tier.
    #[deprecated]
    pub enterprise_config: std::option::Option<crate::model::EnterpriseConfig>,

    /// Secret CSI driver configuration.
    pub secret_manager_config: std::option::Option<crate::model::SecretManagerConfig>,

    /// Optional. Deprecated: Compliance Posture is no longer supported.
    /// For more details, see
    /// <https://cloud.google.com/kubernetes-engine/docs/deprecations/posture-management-deprecation>.
    ///
    /// Enable/Disable Compliance Posture features for the cluster.
    #[deprecated]
    pub compliance_posture_config: std::option::Option<crate::model::CompliancePostureConfig>,

    /// Output only. Reserved for future use.
    pub satisfies_pzs: std::option::Option<bool>,

    /// Output only. Reserved for future use.
    pub satisfies_pzi: std::option::Option<bool>,

    /// The Custom keys configuration for the cluster.
    pub user_managed_keys_config: std::option::Option<crate::model::UserManagedKeysConfig>,

    /// RBACBindingConfig allows user to restrict ClusterRoleBindings an
    /// RoleBindings that can be created.
    pub rbac_binding_config: std::option::Option<crate::model::RBACBindingConfig>,

    /// Configuration for GKE auto upgrades.
    pub gke_auto_upgrade_config: std::option::Option<crate::model::GkeAutoUpgradeConfig>,

    /// Configuration for limiting anonymous access to all endpoints except the
    /// health checks.
    pub anonymous_authentication_config:
        std::option::Option<crate::model::AnonymousAuthenticationConfig>,

    /// Optional. Configuration for scheduled upgrades.
    pub schedule_upgrade_config: std::option::Option<crate::model::ScheduleUpgradeConfig>,

    /// Configuration for sync Secret Manager secrets as k8s secrets.
    pub secret_sync_config: std::option::Option<crate::model::SecretSyncConfig>,

    /// Configuration for Managed OpenTelemetry pipeline.
    pub managed_opentelemetry_config: std::option::Option<crate::model::ManagedOpenTelemetryConfig>,

    /// Configuration for control plane egress control.
    pub control_plane_egress: std::option::Option<crate::model::ControlPlaneEgress>,

    /// Configuration for Managed Machine Learning Diagnostics.
    pub managed_machine_learning_diagnostics_config:
        std::option::Option<crate::model::ManagedMachineLearningDiagnosticsConfig>,

    /// Optional. Configuration for Node Creation Mode.
    pub node_creation_config: std::option::Option<crate::model::NodeCreationConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Cluster {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Cluster::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [description][crate::model::Cluster::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [initial_node_count][crate::model::Cluster::initial_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_initial_node_count(42);
    /// ```
    #[deprecated]
    pub fn set_initial_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.initial_node_count = v.into();
        self
    }

    /// Sets the value of [node_config][crate::model::Cluster::node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodeConfig;
    /// let x = Cluster::new().set_node_config(NodeConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfig>,
    {
        self.node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_config][crate::model::Cluster::node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodeConfig;
    /// let x = Cluster::new().set_or_clear_node_config(Some(NodeConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_node_config(None::<NodeConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfig>,
    {
        self.node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [master_auth][crate::model::Cluster::master_auth].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MasterAuth;
    /// let x = Cluster::new().set_master_auth(MasterAuth::default()/* use setters */);
    /// ```
    pub fn set_master_auth<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuth>,
    {
        self.master_auth = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [master_auth][crate::model::Cluster::master_auth].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MasterAuth;
    /// let x = Cluster::new().set_or_clear_master_auth(Some(MasterAuth::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_master_auth(None::<MasterAuth>);
    /// ```
    pub fn set_or_clear_master_auth<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuth>,
    {
        self.master_auth = v.map(|x| x.into());
        self
    }

    /// Sets the value of [logging_service][crate::model::Cluster::logging_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_logging_service("example");
    /// ```
    pub fn set_logging_service<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.logging_service = v.into();
        self
    }

    /// Sets the value of [monitoring_service][crate::model::Cluster::monitoring_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_monitoring_service("example");
    /// ```
    pub fn set_monitoring_service<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.monitoring_service = v.into();
        self
    }

    /// Sets the value of [network][crate::model::Cluster::network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_network("example");
    /// ```
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [cluster_ipv4_cidr][crate::model::Cluster::cluster_ipv4_cidr].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_cluster_ipv4_cidr("example");
    /// ```
    pub fn set_cluster_ipv4_cidr<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_ipv4_cidr = v.into();
        self
    }

    /// Sets the value of [addons_config][crate::model::Cluster::addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = Cluster::new().set_addons_config(AddonsConfig::default()/* use setters */);
    /// ```
    pub fn set_addons_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.addons_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [addons_config][crate::model::Cluster::addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = Cluster::new().set_or_clear_addons_config(Some(AddonsConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_addons_config(None::<AddonsConfig>);
    /// ```
    pub fn set_or_clear_addons_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.addons_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [subnetwork][crate::model::Cluster::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [node_pools][crate::model::Cluster::node_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodePool;
    /// let x = Cluster::new()
    ///     .set_node_pools([
    ///         NodePool::default()/* use setters */,
    ///         NodePool::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_node_pools<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::NodePool>,
    {
        use std::iter::Iterator;
        self.node_pools = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [locations][crate::model::Cluster::locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_locations(["a", "b", "c"]);
    /// ```
    pub fn set_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [enable_kubernetes_alpha][crate::model::Cluster::enable_kubernetes_alpha].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_enable_kubernetes_alpha(true);
    /// ```
    pub fn set_enable_kubernetes_alpha<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_kubernetes_alpha = v.into();
        self
    }

    /// Sets the value of [alpha_cluster_feature_gates][crate::model::Cluster::alpha_cluster_feature_gates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_alpha_cluster_feature_gates(["a", "b", "c"]);
    /// ```
    pub fn set_alpha_cluster_feature_gates<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.alpha_cluster_feature_gates = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [resource_labels][crate::model::Cluster::resource_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_resource_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_resource_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.resource_labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [label_fingerprint][crate::model::Cluster::label_fingerprint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_label_fingerprint("example");
    /// ```
    pub fn set_label_fingerprint<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.label_fingerprint = v.into();
        self
    }

    /// Sets the value of [legacy_abac][crate::model::Cluster::legacy_abac].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::LegacyAbac;
    /// let x = Cluster::new().set_legacy_abac(LegacyAbac::default()/* use setters */);
    /// ```
    pub fn set_legacy_abac<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LegacyAbac>,
    {
        self.legacy_abac = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [legacy_abac][crate::model::Cluster::legacy_abac].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::LegacyAbac;
    /// let x = Cluster::new().set_or_clear_legacy_abac(Some(LegacyAbac::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_legacy_abac(None::<LegacyAbac>);
    /// ```
    pub fn set_or_clear_legacy_abac<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LegacyAbac>,
    {
        self.legacy_abac = v.map(|x| x.into());
        self
    }

    /// Sets the value of [network_policy][crate::model::Cluster::network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NetworkPolicy;
    /// let x = Cluster::new().set_network_policy(NetworkPolicy::default()/* use setters */);
    /// ```
    pub fn set_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicy>,
    {
        self.network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_policy][crate::model::Cluster::network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NetworkPolicy;
    /// let x = Cluster::new().set_or_clear_network_policy(Some(NetworkPolicy::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_network_policy(None::<NetworkPolicy>);
    /// ```
    pub fn set_or_clear_network_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicy>,
    {
        self.network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ip_allocation_policy][crate::model::Cluster::ip_allocation_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = Cluster::new().set_ip_allocation_policy(IPAllocationPolicy::default()/* use setters */);
    /// ```
    pub fn set_ip_allocation_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::IPAllocationPolicy>,
    {
        self.ip_allocation_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ip_allocation_policy][crate::model::Cluster::ip_allocation_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::IPAllocationPolicy;
    /// let x = Cluster::new().set_or_clear_ip_allocation_policy(Some(IPAllocationPolicy::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_ip_allocation_policy(None::<IPAllocationPolicy>);
    /// ```
    pub fn set_or_clear_ip_allocation_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::IPAllocationPolicy>,
    {
        self.ip_allocation_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [master_authorized_networks_config][crate::model::Cluster::master_authorized_networks_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = Cluster::new().set_master_authorized_networks_config(MasterAuthorizedNetworksConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_master_authorized_networks_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
    {
        self.master_authorized_networks_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [master_authorized_networks_config][crate::model::Cluster::master_authorized_networks_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = Cluster::new().set_or_clear_master_authorized_networks_config(Some(MasterAuthorizedNetworksConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_master_authorized_networks_config(None::<MasterAuthorizedNetworksConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_master_authorized_networks_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
    {
        self.master_authorized_networks_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [maintenance_policy][crate::model::Cluster::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MaintenancePolicy;
    /// let x = Cluster::new().set_maintenance_policy(MaintenancePolicy::default()/* use setters */);
    /// ```
    pub fn set_maintenance_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [maintenance_policy][crate::model::Cluster::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MaintenancePolicy;
    /// let x = Cluster::new().set_or_clear_maintenance_policy(Some(MaintenancePolicy::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_maintenance_policy(None::<MaintenancePolicy>);
    /// ```
    pub fn set_or_clear_maintenance_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [binary_authorization][crate::model::Cluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::BinaryAuthorization;
    /// let x = Cluster::new().set_binary_authorization(BinaryAuthorization::default()/* use setters */);
    /// ```
    pub fn set_binary_authorization<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BinaryAuthorization>,
    {
        self.binary_authorization = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [binary_authorization][crate::model::Cluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::BinaryAuthorization;
    /// let x = Cluster::new().set_or_clear_binary_authorization(Some(BinaryAuthorization::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_binary_authorization(None::<BinaryAuthorization>);
    /// ```
    pub fn set_or_clear_binary_authorization<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BinaryAuthorization>,
    {
        self.binary_authorization = v.map(|x| x.into());
        self
    }

    /// Sets the value of [autoscaling][crate::model::Cluster::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = Cluster::new().set_autoscaling(ClusterAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClusterAutoscaling>,
    {
        self.autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autoscaling][crate::model::Cluster::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = Cluster::new().set_or_clear_autoscaling(Some(ClusterAutoscaling::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_autoscaling(None::<ClusterAutoscaling>);
    /// ```
    pub fn set_or_clear_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ClusterAutoscaling>,
    {
        self.autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [network_config][crate::model::Cluster::network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NetworkConfig;
    /// let x = Cluster::new().set_network_config(NetworkConfig::default()/* use setters */);
    /// ```
    pub fn set_network_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkConfig>,
    {
        self.network_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_config][crate::model::Cluster::network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NetworkConfig;
    /// let x = Cluster::new().set_or_clear_network_config(Some(NetworkConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_network_config(None::<NetworkConfig>);
    /// ```
    pub fn set_or_clear_network_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkConfig>,
    {
        self.network_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [default_max_pods_constraint][crate::model::Cluster::default_max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = Cluster::new().set_default_max_pods_constraint(MaxPodsConstraint::default()/* use setters */);
    /// ```
    pub fn set_default_max_pods_constraint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.default_max_pods_constraint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [default_max_pods_constraint][crate::model::Cluster::default_max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = Cluster::new().set_or_clear_default_max_pods_constraint(Some(MaxPodsConstraint::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_default_max_pods_constraint(None::<MaxPodsConstraint>);
    /// ```
    pub fn set_or_clear_default_max_pods_constraint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.default_max_pods_constraint = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_usage_export_config][crate::model::Cluster::resource_usage_export_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// let x = Cluster::new().set_resource_usage_export_config(ResourceUsageExportConfig::default()/* use setters */);
    /// ```
    pub fn set_resource_usage_export_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceUsageExportConfig>,
    {
        self.resource_usage_export_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [resource_usage_export_config][crate::model::Cluster::resource_usage_export_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// let x = Cluster::new().set_or_clear_resource_usage_export_config(Some(ResourceUsageExportConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_resource_usage_export_config(None::<ResourceUsageExportConfig>);
    /// ```
    pub fn set_or_clear_resource_usage_export_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResourceUsageExportConfig>,
    {
        self.resource_usage_export_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [authenticator_groups_config][crate::model::Cluster::authenticator_groups_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = Cluster::new().set_authenticator_groups_config(AuthenticatorGroupsConfig::default()/* use setters */);
    /// ```
    pub fn set_authenticator_groups_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AuthenticatorGroupsConfig>,
    {
        self.authenticator_groups_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [authenticator_groups_config][crate::model::Cluster::authenticator_groups_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = Cluster::new().set_or_clear_authenticator_groups_config(Some(AuthenticatorGroupsConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_authenticator_groups_config(None::<AuthenticatorGroupsConfig>);
    /// ```
    pub fn set_or_clear_authenticator_groups_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AuthenticatorGroupsConfig>,
    {
        self.authenticator_groups_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [private_cluster_config][crate::model::Cluster::private_cluster_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = Cluster::new().set_private_cluster_config(PrivateClusterConfig::default()/* use setters */);
    /// ```
    pub fn set_private_cluster_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterConfig>,
    {
        self.private_cluster_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [private_cluster_config][crate::model::Cluster::private_cluster_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = Cluster::new().set_or_clear_private_cluster_config(Some(PrivateClusterConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_private_cluster_config(None::<PrivateClusterConfig>);
    /// ```
    pub fn set_or_clear_private_cluster_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterConfig>,
    {
        self.private_cluster_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [database_encryption][crate::model::Cluster::database_encryption].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = Cluster::new().set_database_encryption(DatabaseEncryption::default()/* use setters */);
    /// ```
    pub fn set_database_encryption<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DatabaseEncryption>,
    {
        self.database_encryption = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [database_encryption][crate::model::Cluster::database_encryption].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = Cluster::new().set_or_clear_database_encryption(Some(DatabaseEncryption::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_database_encryption(None::<DatabaseEncryption>);
    /// ```
    pub fn set_or_clear_database_encryption<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DatabaseEncryption>,
    {
        self.database_encryption = v.map(|x| x.into());
        self
    }

    /// Sets the value of [vertical_pod_autoscaling][crate::model::Cluster::vertical_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::VerticalPodAutoscaling;
    /// let x = Cluster::new().set_vertical_pod_autoscaling(VerticalPodAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_vertical_pod_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::VerticalPodAutoscaling>,
    {
        self.vertical_pod_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [vertical_pod_autoscaling][crate::model::Cluster::vertical_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::VerticalPodAutoscaling;
    /// let x = Cluster::new().set_or_clear_vertical_pod_autoscaling(Some(VerticalPodAutoscaling::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_vertical_pod_autoscaling(None::<VerticalPodAutoscaling>);
    /// ```
    pub fn set_or_clear_vertical_pod_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::VerticalPodAutoscaling>,
    {
        self.vertical_pod_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [shielded_nodes][crate::model::Cluster::shielded_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ShieldedNodes;
    /// let x = Cluster::new().set_shielded_nodes(ShieldedNodes::default()/* use setters */);
    /// ```
    pub fn set_shielded_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedNodes>,
    {
        self.shielded_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [shielded_nodes][crate::model::Cluster::shielded_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ShieldedNodes;
    /// let x = Cluster::new().set_or_clear_shielded_nodes(Some(ShieldedNodes::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_shielded_nodes(None::<ShieldedNodes>);
    /// ```
    pub fn set_or_clear_shielded_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedNodes>,
    {
        self.shielded_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [release_channel][crate::model::Cluster::release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = Cluster::new().set_release_channel(ReleaseChannel::default()/* use setters */);
    /// ```
    pub fn set_release_channel<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.release_channel = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [release_channel][crate::model::Cluster::release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = Cluster::new().set_or_clear_release_channel(Some(ReleaseChannel::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_release_channel(None::<ReleaseChannel>);
    /// ```
    pub fn set_or_clear_release_channel<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.release_channel = v.map(|x| x.into());
        self
    }

    /// Sets the value of [workload_identity_config][crate::model::Cluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::WorkloadIdentityConfig;
    /// let x = Cluster::new().set_workload_identity_config(WorkloadIdentityConfig::default()/* use setters */);
    /// ```
    pub fn set_workload_identity_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadIdentityConfig>,
    {
        self.workload_identity_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [workload_identity_config][crate::model::Cluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::WorkloadIdentityConfig;
    /// let x = Cluster::new().set_or_clear_workload_identity_config(Some(WorkloadIdentityConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_workload_identity_config(None::<WorkloadIdentityConfig>);
    /// ```
    pub fn set_or_clear_workload_identity_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadIdentityConfig>,
    {
        self.workload_identity_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [mesh_certificates][crate::model::Cluster::mesh_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MeshCertificates;
    /// let x = Cluster::new().set_mesh_certificates(MeshCertificates::default()/* use setters */);
    /// ```
    pub fn set_mesh_certificates<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MeshCertificates>,
    {
        self.mesh_certificates = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [mesh_certificates][crate::model::Cluster::mesh_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MeshCertificates;
    /// let x = Cluster::new().set_or_clear_mesh_certificates(Some(MeshCertificates::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_mesh_certificates(None::<MeshCertificates>);
    /// ```
    pub fn set_or_clear_mesh_certificates<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MeshCertificates>,
    {
        self.mesh_certificates = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cost_management_config][crate::model::Cluster::cost_management_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::CostManagementConfig;
    /// let x = Cluster::new().set_cost_management_config(CostManagementConfig::default()/* use setters */);
    /// ```
    pub fn set_cost_management_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CostManagementConfig>,
    {
        self.cost_management_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cost_management_config][crate::model::Cluster::cost_management_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::CostManagementConfig;
    /// let x = Cluster::new().set_or_clear_cost_management_config(Some(CostManagementConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_cost_management_config(None::<CostManagementConfig>);
    /// ```
    pub fn set_or_clear_cost_management_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CostManagementConfig>,
    {
        self.cost_management_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [notification_config][crate::model::Cluster::notification_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NotificationConfig;
    /// let x = Cluster::new().set_notification_config(NotificationConfig::default()/* use setters */);
    /// ```
    pub fn set_notification_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NotificationConfig>,
    {
        self.notification_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [notification_config][crate::model::Cluster::notification_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NotificationConfig;
    /// let x = Cluster::new().set_or_clear_notification_config(Some(NotificationConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_notification_config(None::<NotificationConfig>);
    /// ```
    pub fn set_or_clear_notification_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NotificationConfig>,
    {
        self.notification_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [confidential_nodes][crate::model::Cluster::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = Cluster::new().set_confidential_nodes(ConfidentialNodes::default()/* use setters */);
    /// ```
    pub fn set_confidential_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [confidential_nodes][crate::model::Cluster::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = Cluster::new().set_or_clear_confidential_nodes(Some(ConfidentialNodes::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_confidential_nodes(None::<ConfidentialNodes>);
    /// ```
    pub fn set_or_clear_confidential_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [identity_service_config][crate::model::Cluster::identity_service_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::IdentityServiceConfig;
    /// let x = Cluster::new().set_identity_service_config(IdentityServiceConfig::default()/* use setters */);
    /// ```
    pub fn set_identity_service_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::IdentityServiceConfig>,
    {
        self.identity_service_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [identity_service_config][crate::model::Cluster::identity_service_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::IdentityServiceConfig;
    /// let x = Cluster::new().set_or_clear_identity_service_config(Some(IdentityServiceConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_identity_service_config(None::<IdentityServiceConfig>);
    /// ```
    pub fn set_or_clear_identity_service_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::IdentityServiceConfig>,
    {
        self.identity_service_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [self_link][crate::model::Cluster::self_link].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_self_link("example");
    /// ```
    pub fn set_self_link<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.self_link = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::Cluster::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [endpoint][crate::model::Cluster::endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_endpoint("example");
    /// ```
    pub fn set_endpoint<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.endpoint = v.into();
        self
    }

    /// Sets the value of [initial_cluster_version][crate::model::Cluster::initial_cluster_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_initial_cluster_version("example");
    /// ```
    pub fn set_initial_cluster_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.initial_cluster_version = v.into();
        self
    }

    /// Sets the value of [current_master_version][crate::model::Cluster::current_master_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_current_master_version("example");
    /// ```
    pub fn set_current_master_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.current_master_version = v.into();
        self
    }

    /// Sets the value of [current_node_version][crate::model::Cluster::current_node_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_current_node_version("example");
    /// ```
    #[deprecated]
    pub fn set_current_node_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.current_node_version = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::Cluster::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_create_time("example");
    /// ```
    pub fn set_create_time<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.create_time = v.into();
        self
    }

    /// Sets the value of [status][crate::model::Cluster::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::cluster::Status;
    /// let x0 = Cluster::new().set_status(Status::Provisioning);
    /// let x1 = Cluster::new().set_status(Status::Running);
    /// let x2 = Cluster::new().set_status(Status::Reconciling);
    /// ```
    pub fn set_status<T: std::convert::Into<crate::model::cluster::Status>>(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::Cluster::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_status_message("example");
    /// ```
    #[deprecated]
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [node_ipv4_cidr_size][crate::model::Cluster::node_ipv4_cidr_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_node_ipv4_cidr_size(42);
    /// ```
    pub fn set_node_ipv4_cidr_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.node_ipv4_cidr_size = v.into();
        self
    }

    /// Sets the value of [services_ipv4_cidr][crate::model::Cluster::services_ipv4_cidr].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_services_ipv4_cidr("example");
    /// ```
    pub fn set_services_ipv4_cidr<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.services_ipv4_cidr = v.into();
        self
    }

    /// Sets the value of [instance_group_urls][crate::model::Cluster::instance_group_urls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_instance_group_urls(["a", "b", "c"]);
    /// ```
    #[deprecated]
    pub fn set_instance_group_urls<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.instance_group_urls = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [current_node_count][crate::model::Cluster::current_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_current_node_count(42);
    /// ```
    #[deprecated]
    pub fn set_current_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.current_node_count = v.into();
        self
    }

    /// Sets the value of [expire_time][crate::model::Cluster::expire_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_expire_time("example");
    /// ```
    pub fn set_expire_time<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.expire_time = v.into();
        self
    }

    /// Sets the value of [location][crate::model::Cluster::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_location("example");
    /// ```
    pub fn set_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location = v.into();
        self
    }

    /// Sets the value of [enable_tpu][crate::model::Cluster::enable_tpu].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_enable_tpu(true);
    /// ```
    #[deprecated]
    pub fn set_enable_tpu<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_tpu = v.into();
        self
    }

    /// Sets the value of [tpu_ipv4_cidr_block][crate::model::Cluster::tpu_ipv4_cidr_block].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_tpu_ipv4_cidr_block("example");
    /// ```
    #[deprecated]
    pub fn set_tpu_ipv4_cidr_block<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.tpu_ipv4_cidr_block = v.into();
        self
    }

    /// Sets the value of [conditions][crate::model::Cluster::conditions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::StatusCondition;
    /// let x = Cluster::new()
    ///     .set_conditions([
    ///         StatusCondition::default()/* use setters */,
    ///         StatusCondition::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_conditions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::StatusCondition>,
    {
        use std::iter::Iterator;
        self.conditions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [autopilot][crate::model::Cluster::autopilot].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::Autopilot;
    /// let x = Cluster::new().set_autopilot(Autopilot::default()/* use setters */);
    /// ```
    pub fn set_autopilot<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Autopilot>,
    {
        self.autopilot = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autopilot][crate::model::Cluster::autopilot].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::Autopilot;
    /// let x = Cluster::new().set_or_clear_autopilot(Some(Autopilot::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_autopilot(None::<Autopilot>);
    /// ```
    pub fn set_or_clear_autopilot<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Autopilot>,
    {
        self.autopilot = v.map(|x| x.into());
        self
    }

    /// Sets the value of [id][crate::model::Cluster::id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_id("example");
    /// ```
    pub fn set_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.id = v.into();
        self
    }

    /// Sets the value of [node_pool_defaults][crate::model::Cluster::node_pool_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodePoolDefaults;
    /// let x = Cluster::new().set_node_pool_defaults(NodePoolDefaults::default()/* use setters */);
    /// ```
    pub fn set_node_pool_defaults<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolDefaults>,
    {
        self.node_pool_defaults = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_pool_defaults][crate::model::Cluster::node_pool_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodePoolDefaults;
    /// let x = Cluster::new().set_or_clear_node_pool_defaults(Some(NodePoolDefaults::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_node_pool_defaults(None::<NodePoolDefaults>);
    /// ```
    pub fn set_or_clear_node_pool_defaults<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolDefaults>,
    {
        self.node_pool_defaults = v.map(|x| x.into());
        self
    }

    /// Sets the value of [logging_config][crate::model::Cluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::LoggingConfig;
    /// let x = Cluster::new().set_logging_config(LoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LoggingConfig>,
    {
        self.logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [logging_config][crate::model::Cluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::LoggingConfig;
    /// let x = Cluster::new().set_or_clear_logging_config(Some(LoggingConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_logging_config(None::<LoggingConfig>);
    /// ```
    pub fn set_or_clear_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LoggingConfig>,
    {
        self.logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [monitoring_config][crate::model::Cluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MonitoringConfig;
    /// let x = Cluster::new().set_monitoring_config(MonitoringConfig::default()/* use setters */);
    /// ```
    pub fn set_monitoring_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringConfig>,
    {
        self.monitoring_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [monitoring_config][crate::model::Cluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::MonitoringConfig;
    /// let x = Cluster::new().set_or_clear_monitoring_config(Some(MonitoringConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_monitoring_config(None::<MonitoringConfig>);
    /// ```
    pub fn set_or_clear_monitoring_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringConfig>,
    {
        self.monitoring_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_pool_auto_config][crate::model::Cluster::node_pool_auto_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// let x = Cluster::new().set_node_pool_auto_config(NodePoolAutoConfig::default()/* use setters */);
    /// ```
    pub fn set_node_pool_auto_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoConfig>,
    {
        self.node_pool_auto_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_pool_auto_config][crate::model::Cluster::node_pool_auto_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// let x = Cluster::new().set_or_clear_node_pool_auto_config(Some(NodePoolAutoConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_node_pool_auto_config(None::<NodePoolAutoConfig>);
    /// ```
    pub fn set_or_clear_node_pool_auto_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoConfig>,
    {
        self.node_pool_auto_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [pod_autoscaling][crate::model::Cluster::pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::PodAutoscaling;
    /// let x = Cluster::new().set_pod_autoscaling(PodAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_pod_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PodAutoscaling>,
    {
        self.pod_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pod_autoscaling][crate::model::Cluster::pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::PodAutoscaling;
    /// let x = Cluster::new().set_or_clear_pod_autoscaling(Some(PodAutoscaling::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_pod_autoscaling(None::<PodAutoscaling>);
    /// ```
    pub fn set_or_clear_pod_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PodAutoscaling>,
    {
        self.pod_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [etag][crate::model::Cluster::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }

    /// Sets the value of [fleet][crate::model::Cluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::Fleet;
    /// let x = Cluster::new().set_fleet(Fleet::default()/* use setters */);
    /// ```
    pub fn set_fleet<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Fleet>,
    {
        self.fleet = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [fleet][crate::model::Cluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::Fleet;
    /// let x = Cluster::new().set_or_clear_fleet(Some(Fleet::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_fleet(None::<Fleet>);
    /// ```
    pub fn set_or_clear_fleet<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Fleet>,
    {
        self.fleet = v.map(|x| x.into());
        self
    }

    /// Sets the value of [security_posture_config][crate::model::Cluster::security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecurityPostureConfig;
    /// let x = Cluster::new().set_security_posture_config(SecurityPostureConfig::default()/* use setters */);
    /// ```
    pub fn set_security_posture_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecurityPostureConfig>,
    {
        self.security_posture_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [security_posture_config][crate::model::Cluster::security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecurityPostureConfig;
    /// let x = Cluster::new().set_or_clear_security_posture_config(Some(SecurityPostureConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_security_posture_config(None::<SecurityPostureConfig>);
    /// ```
    pub fn set_or_clear_security_posture_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SecurityPostureConfig>,
    {
        self.security_posture_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [control_plane_endpoints_config][crate::model::Cluster::control_plane_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// let x = Cluster::new().set_control_plane_endpoints_config(ControlPlaneEndpointsConfig::default()/* use setters */);
    /// ```
    pub fn set_control_plane_endpoints_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEndpointsConfig>,
    {
        self.control_plane_endpoints_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [control_plane_endpoints_config][crate::model::Cluster::control_plane_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// let x = Cluster::new().set_or_clear_control_plane_endpoints_config(Some(ControlPlaneEndpointsConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_control_plane_endpoints_config(None::<ControlPlaneEndpointsConfig>);
    /// ```
    pub fn set_or_clear_control_plane_endpoints_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEndpointsConfig>,
    {
        self.control_plane_endpoints_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_k8s_beta_apis][crate::model::Cluster::enable_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = Cluster::new().set_enable_k8s_beta_apis(K8sBetaAPIConfig::default()/* use setters */);
    /// ```
    pub fn set_enable_k8s_beta_apis<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.enable_k8s_beta_apis = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_k8s_beta_apis][crate::model::Cluster::enable_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = Cluster::new().set_or_clear_enable_k8s_beta_apis(Some(K8sBetaAPIConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_enable_k8s_beta_apis(None::<K8sBetaAPIConfig>);
    /// ```
    pub fn set_or_clear_enable_k8s_beta_apis<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.enable_k8s_beta_apis = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enterprise_config][crate::model::Cluster::enterprise_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::EnterpriseConfig;
    /// let x = Cluster::new().set_enterprise_config(EnterpriseConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_enterprise_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::EnterpriseConfig>,
    {
        self.enterprise_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enterprise_config][crate::model::Cluster::enterprise_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::EnterpriseConfig;
    /// let x = Cluster::new().set_or_clear_enterprise_config(Some(EnterpriseConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_enterprise_config(None::<EnterpriseConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_enterprise_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::EnterpriseConfig>,
    {
        self.enterprise_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [secret_manager_config][crate::model::Cluster::secret_manager_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = Cluster::new().set_secret_manager_config(SecretManagerConfig::default()/* use setters */);
    /// ```
    pub fn set_secret_manager_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecretManagerConfig>,
    {
        self.secret_manager_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [secret_manager_config][crate::model::Cluster::secret_manager_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = Cluster::new().set_or_clear_secret_manager_config(Some(SecretManagerConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_secret_manager_config(None::<SecretManagerConfig>);
    /// ```
    pub fn set_or_clear_secret_manager_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SecretManagerConfig>,
    {
        self.secret_manager_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [compliance_posture_config][crate::model::Cluster::compliance_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::CompliancePostureConfig;
    /// let x = Cluster::new().set_compliance_posture_config(CompliancePostureConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_compliance_posture_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CompliancePostureConfig>,
    {
        self.compliance_posture_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [compliance_posture_config][crate::model::Cluster::compliance_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::CompliancePostureConfig;
    /// let x = Cluster::new().set_or_clear_compliance_posture_config(Some(CompliancePostureConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_compliance_posture_config(None::<CompliancePostureConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_compliance_posture_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::CompliancePostureConfig>,
    {
        self.compliance_posture_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [satisfies_pzs][crate::model::Cluster::satisfies_pzs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_satisfies_pzs(true);
    /// ```
    pub fn set_satisfies_pzs<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.satisfies_pzs = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [satisfies_pzs][crate::model::Cluster::satisfies_pzs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_or_clear_satisfies_pzs(Some(false));
    /// let x = Cluster::new().set_or_clear_satisfies_pzs(None::<bool>);
    /// ```
    pub fn set_or_clear_satisfies_pzs<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.satisfies_pzs = v.map(|x| x.into());
        self
    }

    /// Sets the value of [satisfies_pzi][crate::model::Cluster::satisfies_pzi].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_satisfies_pzi(true);
    /// ```
    pub fn set_satisfies_pzi<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.satisfies_pzi = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [satisfies_pzi][crate::model::Cluster::satisfies_pzi].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// let x = Cluster::new().set_or_clear_satisfies_pzi(Some(false));
    /// let x = Cluster::new().set_or_clear_satisfies_pzi(None::<bool>);
    /// ```
    pub fn set_or_clear_satisfies_pzi<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.satisfies_pzi = v.map(|x| x.into());
        self
    }

    /// Sets the value of [user_managed_keys_config][crate::model::Cluster::user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = Cluster::new().set_user_managed_keys_config(UserManagedKeysConfig::default()/* use setters */);
    /// ```
    pub fn set_user_managed_keys_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.user_managed_keys_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [user_managed_keys_config][crate::model::Cluster::user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = Cluster::new().set_or_clear_user_managed_keys_config(Some(UserManagedKeysConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_user_managed_keys_config(None::<UserManagedKeysConfig>);
    /// ```
    pub fn set_or_clear_user_managed_keys_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.user_managed_keys_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rbac_binding_config][crate::model::Cluster::rbac_binding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = Cluster::new().set_rbac_binding_config(RBACBindingConfig::default()/* use setters */);
    /// ```
    pub fn set_rbac_binding_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RBACBindingConfig>,
    {
        self.rbac_binding_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rbac_binding_config][crate::model::Cluster::rbac_binding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = Cluster::new().set_or_clear_rbac_binding_config(Some(RBACBindingConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_rbac_binding_config(None::<RBACBindingConfig>);
    /// ```
    pub fn set_or_clear_rbac_binding_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RBACBindingConfig>,
    {
        self.rbac_binding_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gke_auto_upgrade_config][crate::model::Cluster::gke_auto_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::GkeAutoUpgradeConfig;
    /// let x = Cluster::new().set_gke_auto_upgrade_config(GkeAutoUpgradeConfig::default()/* use setters */);
    /// ```
    pub fn set_gke_auto_upgrade_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GkeAutoUpgradeConfig>,
    {
        self.gke_auto_upgrade_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gke_auto_upgrade_config][crate::model::Cluster::gke_auto_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::GkeAutoUpgradeConfig;
    /// let x = Cluster::new().set_or_clear_gke_auto_upgrade_config(Some(GkeAutoUpgradeConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_gke_auto_upgrade_config(None::<GkeAutoUpgradeConfig>);
    /// ```
    pub fn set_or_clear_gke_auto_upgrade_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GkeAutoUpgradeConfig>,
    {
        self.gke_auto_upgrade_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [anonymous_authentication_config][crate::model::Cluster::anonymous_authentication_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AnonymousAuthenticationConfig;
    /// let x = Cluster::new().set_anonymous_authentication_config(AnonymousAuthenticationConfig::default()/* use setters */);
    /// ```
    pub fn set_anonymous_authentication_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AnonymousAuthenticationConfig>,
    {
        self.anonymous_authentication_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [anonymous_authentication_config][crate::model::Cluster::anonymous_authentication_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::AnonymousAuthenticationConfig;
    /// let x = Cluster::new().set_or_clear_anonymous_authentication_config(Some(AnonymousAuthenticationConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_anonymous_authentication_config(None::<AnonymousAuthenticationConfig>);
    /// ```
    pub fn set_or_clear_anonymous_authentication_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AnonymousAuthenticationConfig>,
    {
        self.anonymous_authentication_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [schedule_upgrade_config][crate::model::Cluster::schedule_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ScheduleUpgradeConfig;
    /// let x = Cluster::new().set_schedule_upgrade_config(ScheduleUpgradeConfig::default()/* use setters */);
    /// ```
    pub fn set_schedule_upgrade_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ScheduleUpgradeConfig>,
    {
        self.schedule_upgrade_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [schedule_upgrade_config][crate::model::Cluster::schedule_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ScheduleUpgradeConfig;
    /// let x = Cluster::new().set_or_clear_schedule_upgrade_config(Some(ScheduleUpgradeConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_schedule_upgrade_config(None::<ScheduleUpgradeConfig>);
    /// ```
    pub fn set_or_clear_schedule_upgrade_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ScheduleUpgradeConfig>,
    {
        self.schedule_upgrade_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [secret_sync_config][crate::model::Cluster::secret_sync_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = Cluster::new().set_secret_sync_config(SecretSyncConfig::default()/* use setters */);
    /// ```
    pub fn set_secret_sync_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecretSyncConfig>,
    {
        self.secret_sync_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [secret_sync_config][crate::model::Cluster::secret_sync_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = Cluster::new().set_or_clear_secret_sync_config(Some(SecretSyncConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_secret_sync_config(None::<SecretSyncConfig>);
    /// ```
    pub fn set_or_clear_secret_sync_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SecretSyncConfig>,
    {
        self.secret_sync_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [managed_opentelemetry_config][crate::model::Cluster::managed_opentelemetry_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// let x = Cluster::new().set_managed_opentelemetry_config(ManagedOpenTelemetryConfig::default()/* use setters */);
    /// ```
    pub fn set_managed_opentelemetry_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ManagedOpenTelemetryConfig>,
    {
        self.managed_opentelemetry_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [managed_opentelemetry_config][crate::model::Cluster::managed_opentelemetry_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// let x = Cluster::new().set_or_clear_managed_opentelemetry_config(Some(ManagedOpenTelemetryConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_managed_opentelemetry_config(None::<ManagedOpenTelemetryConfig>);
    /// ```
    pub fn set_or_clear_managed_opentelemetry_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ManagedOpenTelemetryConfig>,
    {
        self.managed_opentelemetry_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [control_plane_egress][crate::model::Cluster::control_plane_egress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ControlPlaneEgress;
    /// let x = Cluster::new().set_control_plane_egress(ControlPlaneEgress::default()/* use setters */);
    /// ```
    pub fn set_control_plane_egress<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEgress>,
    {
        self.control_plane_egress = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [control_plane_egress][crate::model::Cluster::control_plane_egress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ControlPlaneEgress;
    /// let x = Cluster::new().set_or_clear_control_plane_egress(Some(ControlPlaneEgress::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_control_plane_egress(None::<ControlPlaneEgress>);
    /// ```
    pub fn set_or_clear_control_plane_egress<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEgress>,
    {
        self.control_plane_egress = v.map(|x| x.into());
        self
    }

    /// Sets the value of [managed_machine_learning_diagnostics_config][crate::model::Cluster::managed_machine_learning_diagnostics_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = Cluster::new().set_managed_machine_learning_diagnostics_config(ManagedMachineLearningDiagnosticsConfig::default()/* use setters */);
    /// ```
    pub fn set_managed_machine_learning_diagnostics_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ManagedMachineLearningDiagnosticsConfig>,
    {
        self.managed_machine_learning_diagnostics_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [managed_machine_learning_diagnostics_config][crate::model::Cluster::managed_machine_learning_diagnostics_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = Cluster::new().set_or_clear_managed_machine_learning_diagnostics_config(Some(ManagedMachineLearningDiagnosticsConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_managed_machine_learning_diagnostics_config(None::<ManagedMachineLearningDiagnosticsConfig>);
    /// ```
    pub fn set_or_clear_managed_machine_learning_diagnostics_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ManagedMachineLearningDiagnosticsConfig>,
    {
        self.managed_machine_learning_diagnostics_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_creation_config][crate::model::Cluster::node_creation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodeCreationConfig;
    /// let x = Cluster::new().set_node_creation_config(NodeCreationConfig::default()/* use setters */);
    /// ```
    pub fn set_node_creation_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeCreationConfig>,
    {
        self.node_creation_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_creation_config][crate::model::Cluster::node_creation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Cluster;
    /// use google_cloud_container_v1::model::NodeCreationConfig;
    /// let x = Cluster::new().set_or_clear_node_creation_config(Some(NodeCreationConfig::default()/* use setters */));
    /// let x = Cluster::new().set_or_clear_node_creation_config(None::<NodeCreationConfig>);
    /// ```
    pub fn set_or_clear_node_creation_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeCreationConfig>,
    {
        self.node_creation_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Cluster {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.Cluster"
    }
}

/// Defines additional types related to [Cluster].
pub mod cluster {
    #[allow(unused_imports)]
    use super::*;

    /// The current status of the cluster.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Status {
        /// Not set.
        Unspecified,
        /// The PROVISIONING state indicates the cluster is being created.
        Provisioning,
        /// The RUNNING state indicates the cluster has been created and is fully
        /// usable.
        Running,
        /// The RECONCILING state indicates that some work is actively being done on
        /// the cluster, such as upgrading the master or node software. Details can
        /// be found in the `statusMessage` field.
        Reconciling,
        /// The STOPPING state indicates the cluster is being deleted.
        Stopping,
        /// The ERROR state indicates the cluster is unusable. It will be
        /// automatically deleted. Details can be found in the `statusMessage` field.
        Error,
        /// The DEGRADED state indicates the cluster requires user action to restore
        /// full functionality. Details can be found in the `statusMessage` field.
        Degraded,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Status::value] or
        /// [Status::name].
        UnknownValue(status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Status {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Provisioning => std::option::Option::Some(1),
                Self::Running => std::option::Option::Some(2),
                Self::Reconciling => std::option::Option::Some(3),
                Self::Stopping => std::option::Option::Some(4),
                Self::Error => std::option::Option::Some(5),
                Self::Degraded => std::option::Option::Some(6),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATUS_UNSPECIFIED"),
                Self::Provisioning => std::option::Option::Some("PROVISIONING"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::Reconciling => std::option::Option::Some("RECONCILING"),
                Self::Stopping => std::option::Option::Some("STOPPING"),
                Self::Error => std::option::Option::Some("ERROR"),
                Self::Degraded => std::option::Option::Some("DEGRADED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Status {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Status {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Status {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Status {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATUS_UNSPECIFIED" => Self::Unspecified,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Status {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Provisioning => serializer.serialize_i32(1),
                Self::Running => serializer.serialize_i32(2),
                Self::Reconciling => serializer.serialize_i32(3),
                Self::Stopping => serializer.serialize_i32(4),
                Self::Error => serializer.serialize_i32(5),
                Self::Degraded => serializer.serialize_i32(6),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Status {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Status>::new(
                ".google.container.v1.Cluster.Status",
            ))
        }
    }
}

/// NodeCreationConfig defines the settings of node creation mode.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeCreationConfig {
    /// The mode of node creation.
    pub node_creation_mode: crate::model::node_creation_config::Mode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeCreationConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [node_creation_mode][crate::model::NodeCreationConfig::node_creation_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeCreationConfig;
    /// use google_cloud_container_v1::model::node_creation_config::Mode;
    /// let x0 = NodeCreationConfig::new().set_node_creation_mode(Mode::ViaKubelet);
    /// let x1 = NodeCreationConfig::new().set_node_creation_mode(Mode::ViaControlPlane);
    /// ```
    pub fn set_node_creation_mode<
        T: std::convert::Into<crate::model::node_creation_config::Mode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.node_creation_mode = v.into();
        self
    }
}

impl wkt::message::Message for NodeCreationConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeCreationConfig"
    }
}

/// Defines additional types related to [NodeCreationConfig].
pub mod node_creation_config {
    #[allow(unused_imports)]
    use super::*;

    /// The mode of node creation.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// When no user input is provided.
        Unspecified,
        /// Kubelet registers itself.
        ViaKubelet,
        /// gcp-controller-manager automatically creates the node object after
        /// CSR approval.
        ViaControlPlane,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ViaKubelet => std::option::Option::Some(1),
                Self::ViaControlPlane => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::ViaKubelet => std::option::Option::Some("VIA_KUBELET"),
                Self::ViaControlPlane => std::option::Option::Some("VIA_CONTROL_PLANE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ViaKubelet,
                2 => Self::ViaControlPlane,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "VIA_KUBELET" => Self::ViaKubelet,
                "VIA_CONTROL_PLANE" => Self::ViaControlPlane,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ViaKubelet => serializer.serialize_i32(1),
                Self::ViaControlPlane => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.NodeCreationConfig.Mode",
            ))
        }
    }
}

/// ControlPlaneEgress defines the settings needed to enable
/// control plane egress control.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ControlPlaneEgress {
    /// Defines the mode of control plane egress.
    pub mode: crate::model::control_plane_egress::Mode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ControlPlaneEgress {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::ControlPlaneEgress::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ControlPlaneEgress;
    /// use google_cloud_container_v1::model::control_plane_egress::Mode;
    /// let x0 = ControlPlaneEgress::new().set_mode(Mode::ViaControlPlane);
    /// let x1 = ControlPlaneEgress::new().set_mode(Mode::None);
    /// ```
    pub fn set_mode<T: std::convert::Into<crate::model::control_plane_egress::Mode>>(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }
}

impl wkt::message::Message for ControlPlaneEgress {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ControlPlaneEgress"
    }
}

/// Defines additional types related to [ControlPlaneEgress].
pub mod control_plane_egress {
    #[allow(unused_imports)]
    use super::*;

    /// Mode defines the mode of control plane egress.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Default value not specified.
        Unspecified,
        /// Control plane has public IP and no restriction on egress.
        ViaControlPlane,
        /// No public IP on control plane and only internal allowlisted egress.
        None,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ViaControlPlane => std::option::Option::Some(1),
                Self::None => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::ViaControlPlane => std::option::Option::Some("VIA_CONTROL_PLANE"),
                Self::None => std::option::Option::Some("NONE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ViaControlPlane,
                2 => Self::None,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "VIA_CONTROL_PLANE" => Self::ViaControlPlane,
                "NONE" => Self::None,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ViaControlPlane => serializer.serialize_i32(1),
                Self::None => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.ControlPlaneEgress.Mode",
            ))
        }
    }
}

/// RBACBindingConfig allows user to restrict ClusterRoleBindings an RoleBindings
/// that can be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RBACBindingConfig {
    /// Setting this to true will allow any ClusterRoleBinding and RoleBinding
    /// with subjets system:anonymous or system:unauthenticated.
    pub enable_insecure_binding_system_unauthenticated: std::option::Option<bool>,

    /// Setting this to true will allow any ClusterRoleBinding and RoleBinding
    /// with subjects system:authenticated.
    pub enable_insecure_binding_system_authenticated: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RBACBindingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_insecure_binding_system_unauthenticated][crate::model::RBACBindingConfig::enable_insecure_binding_system_unauthenticated].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = RBACBindingConfig::new().set_enable_insecure_binding_system_unauthenticated(true);
    /// ```
    pub fn set_enable_insecure_binding_system_unauthenticated<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_insecure_binding_system_unauthenticated = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_insecure_binding_system_unauthenticated][crate::model::RBACBindingConfig::enable_insecure_binding_system_unauthenticated].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = RBACBindingConfig::new().set_or_clear_enable_insecure_binding_system_unauthenticated(Some(false));
    /// let x = RBACBindingConfig::new().set_or_clear_enable_insecure_binding_system_unauthenticated(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_insecure_binding_system_unauthenticated<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_insecure_binding_system_unauthenticated = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_insecure_binding_system_authenticated][crate::model::RBACBindingConfig::enable_insecure_binding_system_authenticated].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = RBACBindingConfig::new().set_enable_insecure_binding_system_authenticated(true);
    /// ```
    pub fn set_enable_insecure_binding_system_authenticated<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_insecure_binding_system_authenticated = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_insecure_binding_system_authenticated][crate::model::RBACBindingConfig::enable_insecure_binding_system_authenticated].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = RBACBindingConfig::new().set_or_clear_enable_insecure_binding_system_authenticated(Some(false));
    /// let x = RBACBindingConfig::new().set_or_clear_enable_insecure_binding_system_authenticated(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_insecure_binding_system_authenticated<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_insecure_binding_system_authenticated = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for RBACBindingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RBACBindingConfig"
    }
}

/// UserManagedKeysConfig holds the resource address to Keys which are used
/// for signing certs and token that are used for communication within cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UserManagedKeysConfig {
    /// The Certificate Authority Service caPool to use for the cluster CA in this
    /// cluster.
    pub cluster_ca: std::string::String,

    /// Resource path of the Certificate Authority Service caPool to use for the
    /// etcd API CA in this cluster.
    pub etcd_api_ca: std::string::String,

    /// Resource path of the Certificate Authority Service caPool to use for the
    /// etcd peer CA in this cluster.
    pub etcd_peer_ca: std::string::String,

    /// The Cloud KMS cryptoKeyVersions to use for signing service account JWTs
    /// issued by this cluster.
    ///
    /// Format:
    /// `projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{cryptoKey}/cryptoKeyVersions/{cryptoKeyVersion}`
    pub service_account_signing_keys: std::vec::Vec<std::string::String>,

    /// The Cloud KMS cryptoKeyVersions to use for verifying service account JWTs
    /// issued by this cluster.
    ///
    /// Format:
    /// `projects/{project}/locations/{location}/keyRings/{keyring}/cryptoKeys/{cryptoKey}/cryptoKeyVersions/{cryptoKeyVersion}`
    pub service_account_verification_keys: std::vec::Vec<std::string::String>,

    /// The Certificate Authority Service caPool to use for the aggregation CA in
    /// this cluster.
    pub aggregation_ca: std::string::String,

    /// The Cloud KMS cryptoKey to use for Confidential Hyperdisk on the control
    /// plane nodes.
    pub control_plane_disk_encryption_key: std::string::String,

    /// Output only. All of the versions of the Cloud KMS cryptoKey that are used
    /// by Confidential Hyperdisks on the control plane nodes.
    pub control_plane_disk_encryption_key_versions: std::vec::Vec<std::string::String>,

    /// Resource path of the Cloud KMS cryptoKey to use for encryption of internal
    /// etcd backups.
    pub gkeops_etcd_backup_encryption_key: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UserManagedKeysConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [cluster_ca][crate::model::UserManagedKeysConfig::cluster_ca].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_cluster_ca("example");
    /// ```
    pub fn set_cluster_ca<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_ca = v.into();
        self
    }

    /// Sets the value of [etcd_api_ca][crate::model::UserManagedKeysConfig::etcd_api_ca].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_etcd_api_ca("example");
    /// ```
    pub fn set_etcd_api_ca<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etcd_api_ca = v.into();
        self
    }

    /// Sets the value of [etcd_peer_ca][crate::model::UserManagedKeysConfig::etcd_peer_ca].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_etcd_peer_ca("example");
    /// ```
    pub fn set_etcd_peer_ca<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etcd_peer_ca = v.into();
        self
    }

    /// Sets the value of [service_account_signing_keys][crate::model::UserManagedKeysConfig::service_account_signing_keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_service_account_signing_keys(["a", "b", "c"]);
    /// ```
    pub fn set_service_account_signing_keys<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.service_account_signing_keys = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service_account_verification_keys][crate::model::UserManagedKeysConfig::service_account_verification_keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_service_account_verification_keys(["a", "b", "c"]);
    /// ```
    pub fn set_service_account_verification_keys<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.service_account_verification_keys = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [aggregation_ca][crate::model::UserManagedKeysConfig::aggregation_ca].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_aggregation_ca("example");
    /// ```
    pub fn set_aggregation_ca<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.aggregation_ca = v.into();
        self
    }

    /// Sets the value of [control_plane_disk_encryption_key][crate::model::UserManagedKeysConfig::control_plane_disk_encryption_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_control_plane_disk_encryption_key("example");
    /// ```
    pub fn set_control_plane_disk_encryption_key<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.control_plane_disk_encryption_key = v.into();
        self
    }

    /// Sets the value of [control_plane_disk_encryption_key_versions][crate::model::UserManagedKeysConfig::control_plane_disk_encryption_key_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_control_plane_disk_encryption_key_versions(["a", "b", "c"]);
    /// ```
    pub fn set_control_plane_disk_encryption_key_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.control_plane_disk_encryption_key_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [gkeops_etcd_backup_encryption_key][crate::model::UserManagedKeysConfig::gkeops_etcd_backup_encryption_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = UserManagedKeysConfig::new().set_gkeops_etcd_backup_encryption_key("example");
    /// ```
    pub fn set_gkeops_etcd_backup_encryption_key<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.gkeops_etcd_backup_encryption_key = v.into();
        self
    }
}

impl wkt::message::Message for UserManagedKeysConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UserManagedKeysConfig"
    }
}

/// AnonymousAuthenticationConfig defines the settings needed to limit endpoints
/// that allow anonymous authentication.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AnonymousAuthenticationConfig {
    /// Defines the mode of limiting anonymous access in the cluster.
    pub mode: crate::model::anonymous_authentication_config::Mode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AnonymousAuthenticationConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::AnonymousAuthenticationConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AnonymousAuthenticationConfig;
    /// use google_cloud_container_v1::model::anonymous_authentication_config::Mode;
    /// let x0 = AnonymousAuthenticationConfig::new().set_mode(Mode::Enabled);
    /// let x1 = AnonymousAuthenticationConfig::new().set_mode(Mode::Limited);
    /// ```
    pub fn set_mode<T: std::convert::Into<crate::model::anonymous_authentication_config::Mode>>(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }
}

impl wkt::message::Message for AnonymousAuthenticationConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AnonymousAuthenticationConfig"
    }
}

/// Defines additional types related to [AnonymousAuthenticationConfig].
pub mod anonymous_authentication_config {
    #[allow(unused_imports)]
    use super::*;

    /// Mode defines the mode of anonymous authentication
    /// allowed in the cluster.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Default value not specified.
        Unspecified,
        /// Anonymous authentication is allowed for all endpoints.
        Enabled,
        /// Anonymous authentication is allowed for only health check endpoints.
        Limited,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Enabled => std::option::Option::Some(1),
                Self::Limited => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::Enabled => std::option::Option::Some("ENABLED"),
                Self::Limited => std::option::Option::Some("LIMITED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Enabled,
                2 => Self::Limited,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "ENABLED" => Self::Enabled,
                "LIMITED" => Self::Limited,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Enabled => serializer.serialize_i32(1),
                Self::Limited => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.AnonymousAuthenticationConfig.Mode",
            ))
        }
    }
}

/// Deprecated: Compliance Posture is no longer supported.
/// For more details, see
/// <https://cloud.google.com/kubernetes-engine/docs/deprecations/posture-management-deprecation>.
///
/// CompliancePostureConfig defines the settings needed to enable/disable
/// features for the Compliance Posture.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CompliancePostureConfig {
    /// Defines the enablement mode for Compliance Posture.
    pub mode: std::option::Option<crate::model::compliance_posture_config::Mode>,

    /// List of enabled compliance standards.
    pub compliance_standards:
        std::vec::Vec<crate::model::compliance_posture_config::ComplianceStandard>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CompliancePostureConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::CompliancePostureConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompliancePostureConfig;
    /// use google_cloud_container_v1::model::compliance_posture_config::Mode;
    /// let x0 = CompliancePostureConfig::new().set_mode(Mode::Disabled);
    /// let x1 = CompliancePostureConfig::new().set_mode(Mode::Enabled);
    /// ```
    pub fn set_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::compliance_posture_config::Mode>,
    {
        self.mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [mode][crate::model::CompliancePostureConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompliancePostureConfig;
    /// use google_cloud_container_v1::model::compliance_posture_config::Mode;
    /// let x0 = CompliancePostureConfig::new().set_or_clear_mode(Some(Mode::Disabled));
    /// let x1 = CompliancePostureConfig::new().set_or_clear_mode(Some(Mode::Enabled));
    /// let x_none = CompliancePostureConfig::new().set_or_clear_mode(None::<Mode>);
    /// ```
    pub fn set_or_clear_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::compliance_posture_config::Mode>,
    {
        self.mode = v.map(|x| x.into());
        self
    }

    /// Sets the value of [compliance_standards][crate::model::CompliancePostureConfig::compliance_standards].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompliancePostureConfig;
    /// use google_cloud_container_v1::model::compliance_posture_config::ComplianceStandard;
    /// let x = CompliancePostureConfig::new()
    ///     .set_compliance_standards([
    ///         ComplianceStandard::default()/* use setters */,
    ///         ComplianceStandard::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_compliance_standards<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::compliance_posture_config::ComplianceStandard>,
    {
        use std::iter::Iterator;
        self.compliance_standards = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for CompliancePostureConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CompliancePostureConfig"
    }
}

/// Defines additional types related to [CompliancePostureConfig].
pub mod compliance_posture_config {
    #[allow(unused_imports)]
    use super::*;

    /// Defines the details of a compliance standard.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ComplianceStandard {
        /// Name of the compliance standard.
        pub standard: std::option::Option<std::string::String>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ComplianceStandard {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [standard][crate::model::compliance_posture_config::ComplianceStandard::standard].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::compliance_posture_config::ComplianceStandard;
        /// let x = ComplianceStandard::new().set_standard("example");
        /// ```
        pub fn set_standard<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<std::string::String>,
        {
            self.standard = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [standard][crate::model::compliance_posture_config::ComplianceStandard::standard].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::compliance_posture_config::ComplianceStandard;
        /// let x = ComplianceStandard::new().set_or_clear_standard(Some("example"));
        /// let x = ComplianceStandard::new().set_or_clear_standard(None::<String>);
        /// ```
        pub fn set_or_clear_standard<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<std::string::String>,
        {
            self.standard = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ComplianceStandard {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.CompliancePostureConfig.ComplianceStandard"
        }
    }

    /// Mode defines enablement mode for Compliance Posture.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Default value not specified.
        Unspecified,
        /// Disables Compliance Posture features on the cluster.
        Disabled,
        /// Enables Compliance Posture features on the cluster.
        Enabled,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::Enabled => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::Enabled => std::option::Option::Some("ENABLED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                2 => Self::Enabled,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "ENABLED" => Self::Enabled,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::Enabled => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.CompliancePostureConfig.Mode",
            ))
        }
    }
}

/// K8sBetaAPIConfig , configuration for beta APIs
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct K8sBetaAPIConfig {
    /// Enabled k8s beta APIs.
    pub enabled_apis: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl K8sBetaAPIConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled_apis][crate::model::K8sBetaAPIConfig::enabled_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = K8sBetaAPIConfig::new().set_enabled_apis(["a", "b", "c"]);
    /// ```
    pub fn set_enabled_apis<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.enabled_apis = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for K8sBetaAPIConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.K8sBetaAPIConfig"
    }
}

/// SecurityPostureConfig defines the flags needed to enable/disable features for
/// the Security Posture API.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecurityPostureConfig {
    /// Sets which mode to use for Security Posture features.
    pub mode: std::option::Option<crate::model::security_posture_config::Mode>,

    /// Sets which mode to use for vulnerability scanning.
    pub vulnerability_mode:
        std::option::Option<crate::model::security_posture_config::VulnerabilityMode>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecurityPostureConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::SecurityPostureConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityPostureConfig;
    /// use google_cloud_container_v1::model::security_posture_config::Mode;
    /// let x0 = SecurityPostureConfig::new().set_mode(Mode::Disabled);
    /// let x1 = SecurityPostureConfig::new().set_mode(Mode::Basic);
    /// ```
    pub fn set_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::security_posture_config::Mode>,
    {
        self.mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [mode][crate::model::SecurityPostureConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityPostureConfig;
    /// use google_cloud_container_v1::model::security_posture_config::Mode;
    /// let x0 = SecurityPostureConfig::new().set_or_clear_mode(Some(Mode::Disabled));
    /// let x1 = SecurityPostureConfig::new().set_or_clear_mode(Some(Mode::Basic));
    /// let x_none = SecurityPostureConfig::new().set_or_clear_mode(None::<Mode>);
    /// ```
    pub fn set_or_clear_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::security_posture_config::Mode>,
    {
        self.mode = v.map(|x| x.into());
        self
    }

    /// Sets the value of [vulnerability_mode][crate::model::SecurityPostureConfig::vulnerability_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityPostureConfig;
    /// use google_cloud_container_v1::model::security_posture_config::VulnerabilityMode;
    /// let x0 = SecurityPostureConfig::new().set_vulnerability_mode(VulnerabilityMode::VulnerabilityDisabled);
    /// let x1 = SecurityPostureConfig::new().set_vulnerability_mode(VulnerabilityMode::VulnerabilityEnterprise);
    /// ```
    pub fn set_vulnerability_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::security_posture_config::VulnerabilityMode>,
    {
        self.vulnerability_mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [vulnerability_mode][crate::model::SecurityPostureConfig::vulnerability_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityPostureConfig;
    /// use google_cloud_container_v1::model::security_posture_config::VulnerabilityMode;
    /// let x0 = SecurityPostureConfig::new().set_or_clear_vulnerability_mode(Some(VulnerabilityMode::VulnerabilityDisabled));
    /// let x1 = SecurityPostureConfig::new().set_or_clear_vulnerability_mode(Some(VulnerabilityMode::VulnerabilityEnterprise));
    /// let x_none = SecurityPostureConfig::new().set_or_clear_vulnerability_mode(None::<VulnerabilityMode>);
    /// ```
    pub fn set_or_clear_vulnerability_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::security_posture_config::VulnerabilityMode>,
    {
        self.vulnerability_mode = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SecurityPostureConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecurityPostureConfig"
    }
}

/// Defines additional types related to [SecurityPostureConfig].
pub mod security_posture_config {
    #[allow(unused_imports)]
    use super::*;

    /// Mode defines enablement mode for GKE Security posture features.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Default value not specified.
        Unspecified,
        /// Disables Security Posture features on the cluster.
        Disabled,
        /// Applies Security Posture features on the cluster.
        Basic,
        /// Deprecated: Security Posture Enterprise features are no longer supported.
        /// For more details, see
        /// <https://cloud.google.com/kubernetes-engine/docs/deprecations/posture-management-deprecation>.
        ///
        /// Applies the Security Posture off cluster Enterprise level features.
        #[deprecated]
        Enterprise,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::Basic => std::option::Option::Some(2),
                Self::Enterprise => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::Basic => std::option::Option::Some("BASIC"),
                Self::Enterprise => std::option::Option::Some("ENTERPRISE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                2 => Self::Basic,
                3 => Self::Enterprise,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "BASIC" => Self::Basic,
                "ENTERPRISE" => Self::Enterprise,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::Basic => serializer.serialize_i32(2),
                Self::Enterprise => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.SecurityPostureConfig.Mode",
            ))
        }
    }

    /// VulnerabilityMode defines enablement mode for vulnerability scanning.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VulnerabilityMode {
        /// Default value not specified.
        Unspecified,
        /// Disables vulnerability scanning on the cluster.
        VulnerabilityDisabled,
        /// Deprecated: Basic vulnerability scanning is no longer supported.
        /// For more details, see
        /// <https://cloud.google.com/kubernetes-engine/docs/deprecations/posture-management-deprecation>.
        ///
        /// Applies basic vulnerability scanning on the cluster.
        #[deprecated]
        VulnerabilityBasic,
        /// Applies the Security Posture's vulnerability on cluster Enterprise level
        /// features.
        VulnerabilityEnterprise,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [VulnerabilityMode::value] or
        /// [VulnerabilityMode::name].
        UnknownValue(vulnerability_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod vulnerability_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl VulnerabilityMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::VulnerabilityDisabled => std::option::Option::Some(1),
                Self::VulnerabilityBasic => std::option::Option::Some(2),
                Self::VulnerabilityEnterprise => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("VULNERABILITY_MODE_UNSPECIFIED"),
                Self::VulnerabilityDisabled => std::option::Option::Some("VULNERABILITY_DISABLED"),
                Self::VulnerabilityBasic => std::option::Option::Some("VULNERABILITY_BASIC"),
                Self::VulnerabilityEnterprise => {
                    std::option::Option::Some("VULNERABILITY_ENTERPRISE")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for VulnerabilityMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for VulnerabilityMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for VulnerabilityMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::VulnerabilityDisabled,
                2 => Self::VulnerabilityBasic,
                3 => Self::VulnerabilityEnterprise,
                _ => Self::UnknownValue(vulnerability_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for VulnerabilityMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "VULNERABILITY_MODE_UNSPECIFIED" => Self::Unspecified,
                "VULNERABILITY_DISABLED" => Self::VulnerabilityDisabled,
                "VULNERABILITY_BASIC" => Self::VulnerabilityBasic,
                "VULNERABILITY_ENTERPRISE" => Self::VulnerabilityEnterprise,
                _ => Self::UnknownValue(vulnerability_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for VulnerabilityMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::VulnerabilityDisabled => serializer.serialize_i32(1),
                Self::VulnerabilityBasic => serializer.serialize_i32(2),
                Self::VulnerabilityEnterprise => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for VulnerabilityMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<VulnerabilityMode>::new(
                ".google.container.v1.SecurityPostureConfig.VulnerabilityMode",
            ))
        }
    }
}

/// Node pool configs that apply to all auto-provisioned node pools
/// in autopilot clusters and node auto-provisioning enabled clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePoolAutoConfig {
    /// The list of instance tags applied to all nodes. Tags are used to identify
    /// valid sources or targets for network firewalls and are specified by
    /// the client during cluster creation. Each tag within the list
    /// must comply with RFC1035.
    pub network_tags: std::option::Option<crate::model::NetworkTags>,

    /// Resource manager tag keys and values to be attached to the nodes
    /// for managing Compute Engine firewalls using Network Firewall Policies.
    pub resource_manager_tags: std::option::Option<crate::model::ResourceManagerTags>,

    /// NodeKubeletConfig controls the defaults for autoprovisioned node-pools.
    ///
    /// Currently only `insecure_kubelet_readonly_port_enabled` can be set here.
    pub node_kubelet_config: std::option::Option<crate::model::NodeKubeletConfig>,

    /// Output only. Configuration options for Linux nodes.
    pub linux_node_config: std::option::Option<crate::model::LinuxNodeConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePoolAutoConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [network_tags][crate::model::NodePoolAutoConfig::network_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = NodePoolAutoConfig::new().set_network_tags(NetworkTags::default()/* use setters */);
    /// ```
    pub fn set_network_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.network_tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_tags][crate::model::NodePoolAutoConfig::network_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = NodePoolAutoConfig::new().set_or_clear_network_tags(Some(NetworkTags::default()/* use setters */));
    /// let x = NodePoolAutoConfig::new().set_or_clear_network_tags(None::<NetworkTags>);
    /// ```
    pub fn set_or_clear_network_tags<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.network_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_manager_tags][crate::model::NodePoolAutoConfig::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = NodePoolAutoConfig::new().set_resource_manager_tags(ResourceManagerTags::default()/* use setters */);
    /// ```
    pub fn set_resource_manager_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [resource_manager_tags][crate::model::NodePoolAutoConfig::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = NodePoolAutoConfig::new().set_or_clear_resource_manager_tags(Some(ResourceManagerTags::default()/* use setters */));
    /// let x = NodePoolAutoConfig::new().set_or_clear_resource_manager_tags(None::<ResourceManagerTags>);
    /// ```
    pub fn set_or_clear_resource_manager_tags<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_kubelet_config][crate::model::NodePoolAutoConfig::node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodePoolAutoConfig::new().set_node_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_node_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.node_kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_kubelet_config][crate::model::NodePoolAutoConfig::node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodePoolAutoConfig::new().set_or_clear_node_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = NodePoolAutoConfig::new().set_or_clear_node_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_node_kubelet_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.node_kubelet_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [linux_node_config][crate::model::NodePoolAutoConfig::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = NodePoolAutoConfig::new().set_linux_node_config(LinuxNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_linux_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [linux_node_config][crate::model::NodePoolAutoConfig::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoConfig;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = NodePoolAutoConfig::new().set_or_clear_linux_node_config(Some(LinuxNodeConfig::default()/* use setters */));
    /// let x = NodePoolAutoConfig::new().set_or_clear_linux_node_config(None::<LinuxNodeConfig>);
    /// ```
    pub fn set_or_clear_linux_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodePoolAutoConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePoolAutoConfig"
    }
}

/// Subset of Nodepool message that has defaults.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePoolDefaults {
    /// Subset of NodeConfig message that has defaults.
    pub node_config_defaults: std::option::Option<crate::model::NodeConfigDefaults>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePoolDefaults {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [node_config_defaults][crate::model::NodePoolDefaults::node_config_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolDefaults;
    /// use google_cloud_container_v1::model::NodeConfigDefaults;
    /// let x = NodePoolDefaults::new().set_node_config_defaults(NodeConfigDefaults::default()/* use setters */);
    /// ```
    pub fn set_node_config_defaults<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfigDefaults>,
    {
        self.node_config_defaults = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_config_defaults][crate::model::NodePoolDefaults::node_config_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolDefaults;
    /// use google_cloud_container_v1::model::NodeConfigDefaults;
    /// let x = NodePoolDefaults::new().set_or_clear_node_config_defaults(Some(NodeConfigDefaults::default()/* use setters */));
    /// let x = NodePoolDefaults::new().set_or_clear_node_config_defaults(None::<NodeConfigDefaults>);
    /// ```
    pub fn set_or_clear_node_config_defaults<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfigDefaults>,
    {
        self.node_config_defaults = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodePoolDefaults {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePoolDefaults"
    }
}

/// Subset of NodeConfig message that has defaults.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeConfigDefaults {
    /// GCFS (Google Container File System, also known as Riptide) options.
    pub gcfs_config: std::option::Option<crate::model::GcfsConfig>,

    /// Logging configuration for node pools.
    pub logging_config: std::option::Option<crate::model::NodePoolLoggingConfig>,

    /// Parameters for containerd customization.
    pub containerd_config: std::option::Option<crate::model::ContainerdConfig>,

    /// NodeKubeletConfig controls the defaults for new node-pools.
    ///
    /// Currently only `insecure_kubelet_readonly_port_enabled` can be set here.
    pub node_kubelet_config: std::option::Option<crate::model::NodeKubeletConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeConfigDefaults {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [gcfs_config][crate::model::NodeConfigDefaults::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = NodeConfigDefaults::new().set_gcfs_config(GcfsConfig::default()/* use setters */);
    /// ```
    pub fn set_gcfs_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcfs_config][crate::model::NodeConfigDefaults::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = NodeConfigDefaults::new().set_or_clear_gcfs_config(Some(GcfsConfig::default()/* use setters */));
    /// let x = NodeConfigDefaults::new().set_or_clear_gcfs_config(None::<GcfsConfig>);
    /// ```
    pub fn set_or_clear_gcfs_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [logging_config][crate::model::NodeConfigDefaults::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = NodeConfigDefaults::new().set_logging_config(NodePoolLoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [logging_config][crate::model::NodeConfigDefaults::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = NodeConfigDefaults::new().set_or_clear_logging_config(Some(NodePoolLoggingConfig::default()/* use setters */));
    /// let x = NodeConfigDefaults::new().set_or_clear_logging_config(None::<NodePoolLoggingConfig>);
    /// ```
    pub fn set_or_clear_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [containerd_config][crate::model::NodeConfigDefaults::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = NodeConfigDefaults::new().set_containerd_config(ContainerdConfig::default()/* use setters */);
    /// ```
    pub fn set_containerd_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [containerd_config][crate::model::NodeConfigDefaults::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = NodeConfigDefaults::new().set_or_clear_containerd_config(Some(ContainerdConfig::default()/* use setters */));
    /// let x = NodeConfigDefaults::new().set_or_clear_containerd_config(None::<ContainerdConfig>);
    /// ```
    pub fn set_or_clear_containerd_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_kubelet_config][crate::model::NodeConfigDefaults::node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeConfigDefaults::new().set_node_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_node_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.node_kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_kubelet_config][crate::model::NodeConfigDefaults::node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeConfigDefaults;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = NodeConfigDefaults::new().set_or_clear_node_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = NodeConfigDefaults::new().set_or_clear_node_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_node_kubelet_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.node_kubelet_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodeConfigDefaults {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeConfigDefaults"
    }
}

/// ClusterUpdate describes an update to the cluster. Exactly one update can
/// be applied to a cluster with each request, so at most one field can be
/// provided.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClusterUpdate {
    /// The Kubernetes version to change the nodes to (typically an
    /// upgrade).
    ///
    /// Users may specify either explicit versions offered by
    /// Kubernetes Engine or version aliases, which have the following behavior:
    ///
    /// - "latest": picks the highest valid Kubernetes version
    /// - "1.X": picks the highest valid patch+gke.N patch in the 1.X version
    /// - "1.X.Y": picks the highest valid gke.N patch in the 1.X.Y version
    /// - "1.X.Y-gke.N": picks an explicit Kubernetes version
    /// - "-": picks the Kubernetes master version
    pub desired_node_version: std::string::String,

    /// The monitoring service the cluster should use to write metrics.
    /// Currently available options:
    ///
    /// * `monitoring.googleapis.com/kubernetes` - The Cloud Monitoring
    ///   service with a Kubernetes-native resource model
    /// * `monitoring.googleapis.com` - The legacy Cloud Monitoring service (no
    ///   longer available as of GKE 1.15).
    /// * `none` - No metrics will be exported from the cluster.
    ///
    /// If left as an empty string,`monitoring.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `monitoring.googleapis.com` for earlier versions.
    pub desired_monitoring_service: std::string::String,

    /// Configurations for the various addons available to run in the cluster.
    pub desired_addons_config: std::option::Option<crate::model::AddonsConfig>,

    /// The node pool to be upgraded. This field is mandatory if
    /// "desired_node_version", "desired_image_family" or
    /// "desired_node_pool_autoscaling" is specified and there is more than one
    /// node pool on the cluster.
    pub desired_node_pool_id: std::string::String,

    /// The desired image type for the node pool.
    /// NOTE: Set the "desired_node_pool" field as well.
    pub desired_image_type: std::string::String,

    /// The desired name of the image to use for this node.
    /// This is used to create clusters using a custom image.
    /// NOTE: Set the "desired_node_pool" field as well.
    pub desired_image: std::string::String,

    /// The project containing the desired image to use for this node.
    /// This is used to create clusters using a custom image.
    /// NOTE: Set the "desired_node_pool" field as well.
    pub desired_image_project: std::string::String,

    /// Configuration of etcd encryption.
    pub desired_database_encryption: std::option::Option<crate::model::DatabaseEncryption>,

    /// Configuration for Workload Identity.
    pub desired_workload_identity_config: std::option::Option<crate::model::WorkloadIdentityConfig>,

    /// Configuration for issuance of mTLS keys and certificates to Kubernetes
    /// pods.
    pub desired_mesh_certificates: std::option::Option<crate::model::MeshCertificates>,

    /// Configuration for Shielded Nodes.
    pub desired_shielded_nodes: std::option::Option<crate::model::ShieldedNodes>,

    /// The desired configuration for the fine-grained cost management feature.
    pub desired_cost_management_config: std::option::Option<crate::model::CostManagementConfig>,

    /// DNSConfig contains clusterDNS config for this cluster.
    pub desired_dns_config: std::option::Option<crate::model::DNSConfig>,

    /// Autoscaler configuration for the node pool specified in
    /// desired_node_pool_id. If there is only one pool in the
    /// cluster and desired_node_pool_id is not provided then
    /// the change applies to that single node pool.
    pub desired_node_pool_autoscaling: std::option::Option<crate::model::NodePoolAutoscaling>,

    /// The desired list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster's nodes should be located.
    ///
    /// This list must always include the cluster's primary zone.
    ///
    /// Warning: changing cluster locations will update the locations of all node
    /// pools and will result in nodes being added and/or removed.
    pub desired_locations: std::vec::Vec<std::string::String>,

    /// The desired configuration options for master authorized networks feature.
    ///
    /// Deprecated: Use
    /// desired_control_plane_endpoints_config.ip_endpoints_config.authorized_networks_config
    /// instead.
    #[deprecated]
    pub desired_master_authorized_networks_config:
        std::option::Option<crate::model::MasterAuthorizedNetworksConfig>,

    /// Cluster-level autoscaling configuration.
    pub desired_cluster_autoscaling: std::option::Option<crate::model::ClusterAutoscaling>,

    /// The desired configuration options for the Binary Authorization feature.
    pub desired_binary_authorization: std::option::Option<crate::model::BinaryAuthorization>,

    /// The logging service the cluster should use to write logs.
    /// Currently available options:
    ///
    /// * `logging.googleapis.com/kubernetes` - The Cloud Logging
    ///   service with a Kubernetes-native resource model
    /// * `logging.googleapis.com` - The legacy Cloud Logging service (no longer
    ///   available as of GKE 1.15).
    /// * `none` - no logs will be exported from the cluster.
    ///
    /// If left as an empty string,`logging.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `logging.googleapis.com` for earlier versions.
    pub desired_logging_service: std::string::String,

    /// The desired configuration for exporting resource usage.
    pub desired_resource_usage_export_config:
        std::option::Option<crate::model::ResourceUsageExportConfig>,

    /// Cluster-level Vertical Pod Autoscaling configuration.
    pub desired_vertical_pod_autoscaling: std::option::Option<crate::model::VerticalPodAutoscaling>,

    /// The desired private cluster configuration. master_global_access_config is
    /// the only field that can be changed via this field.
    /// See also
    /// [ClusterUpdate.desired_enable_private_endpoint][google.container.v1.ClusterUpdate.desired_enable_private_endpoint]
    /// for modifying other fields within
    /// [PrivateClusterConfig][google.container.v1.PrivateClusterConfig].
    ///
    /// Deprecated: Use
    /// desired_control_plane_endpoints_config.ip_endpoints_config.global_access
    /// instead.
    ///
    /// [google.container.v1.ClusterUpdate.desired_enable_private_endpoint]: crate::model::ClusterUpdate::desired_enable_private_endpoint
    /// [google.container.v1.PrivateClusterConfig]: crate::model::PrivateClusterConfig
    #[deprecated]
    pub desired_private_cluster_config: std::option::Option<crate::model::PrivateClusterConfig>,

    /// The desired config of Intra-node visibility.
    pub desired_intra_node_visibility_config:
        std::option::Option<crate::model::IntraNodeVisibilityConfig>,

    /// The desired status of whether to disable default sNAT for this cluster.
    pub desired_default_snat_status: std::option::Option<crate::model::DefaultSnatStatus>,

    /// The desired release channel configuration.
    pub desired_release_channel: std::option::Option<crate::model::ReleaseChannel>,

    /// The desired L4 Internal Load Balancer Subsetting configuration.
    pub desired_l4ilb_subsetting_config: std::option::Option<crate::model::ILBSubsettingConfig>,

    /// The desired datapath provider for the cluster.
    pub desired_datapath_provider: crate::model::DatapathProvider,

    /// The desired state of IPv6 connectivity to Google Services.
    pub desired_private_ipv6_google_access: crate::model::PrivateIPv6GoogleAccess,

    /// The desired notification configuration.
    pub desired_notification_config: std::option::Option<crate::model::NotificationConfig>,

    /// The desired authenticator groups config for the cluster.
    pub desired_authenticator_groups_config:
        std::option::Option<crate::model::AuthenticatorGroupsConfig>,

    /// The desired logging configuration.
    pub desired_logging_config: std::option::Option<crate::model::LoggingConfig>,

    /// The desired monitoring configuration.
    pub desired_monitoring_config: std::option::Option<crate::model::MonitoringConfig>,

    /// The desired Identity Service component configuration.
    pub desired_identity_service_config: std::option::Option<crate::model::IdentityServiceConfig>,

    /// ServiceExternalIPsConfig specifies the config for the use of Services with
    /// ExternalIPs field.
    pub desired_service_external_ips_config:
        std::option::Option<crate::model::ServiceExternalIPsConfig>,

    /// Enable/Disable private endpoint for the cluster's master.
    ///
    /// Deprecated: Use
    /// desired_control_plane_endpoints_config.ip_endpoints_config.enable_public_endpoint
    /// instead. Note that the value of enable_public_endpoint is reversed: if
    /// enable_private_endpoint is false, then enable_public_endpoint will be true.
    #[deprecated]
    pub desired_enable_private_endpoint: std::option::Option<bool>,

    /// Override the default setting of whether future created
    /// nodes have private IP addresses only, namely
    /// [NetworkConfig.default_enable_private_nodes][google.container.v1.NetworkConfig.default_enable_private_nodes]
    ///
    /// [google.container.v1.NetworkConfig.default_enable_private_nodes]: crate::model::NetworkConfig::default_enable_private_nodes
    pub desired_default_enable_private_nodes: std::option::Option<bool>,

    /// [Control plane
    /// endpoints][google.container.v1.Cluster.control_plane_endpoints_config]
    /// configuration.
    ///
    /// [google.container.v1.Cluster.control_plane_endpoints_config]: crate::model::Cluster::control_plane_endpoints_config
    pub desired_control_plane_endpoints_config:
        std::option::Option<crate::model::ControlPlaneEndpointsConfig>,

    /// The Kubernetes version to change the master to.
    ///
    /// Users may specify either explicit versions offered by
    /// Kubernetes Engine or version aliases, which have the following behavior:
    ///
    /// - "latest": picks the highest valid Kubernetes version
    /// - "1.X": picks the highest valid patch+gke.N patch in the 1.X version
    /// - "1.X.Y": picks the highest valid gke.N patch in the 1.X.Y version
    /// - "1.X.Y-gke.N": picks an explicit Kubernetes version
    /// - "-": picks the default Kubernetes version
    pub desired_master_version: std::string::String,

    /// The desired GCFS config for the cluster
    pub desired_gcfs_config: std::option::Option<crate::model::GcfsConfig>,

    /// The desired network tags that apply to all auto-provisioned node pools
    /// in autopilot clusters and node auto-provisioning enabled clusters.
    pub desired_node_pool_auto_config_network_tags: std::option::Option<crate::model::NetworkTags>,

    /// The desired config for pod autoscaling.
    pub desired_pod_autoscaling: std::option::Option<crate::model::PodAutoscaling>,

    /// The desired config of Gateway API on this cluster.
    pub desired_gateway_api_config: std::option::Option<crate::model::GatewayAPIConfig>,

    /// The current etag of the cluster.
    /// If an etag is provided and does not match the current etag of the cluster,
    /// update will be blocked and an ABORTED error will be returned.
    pub etag: std::string::String,

    /// The desired node pool logging configuration defaults for the cluster.
    pub desired_node_pool_logging_config: std::option::Option<crate::model::NodePoolLoggingConfig>,

    /// The desired fleet configuration for the cluster.
    pub desired_fleet: std::option::Option<crate::model::Fleet>,

    /// The desired stack type of the cluster.
    /// If a stack type is provided and does not match the current stack type of
    /// the cluster, update will attempt to change the stack type to the new type.
    pub desired_stack_type: crate::model::StackType,

    /// The additional pod ranges to be added to the cluster. These pod ranges
    /// can be used by node pools to allocate pod IPs.
    pub additional_pod_ranges_config: std::option::Option<crate::model::AdditionalPodRangesConfig>,

    /// The additional pod ranges that are to be removed from the cluster.
    /// The pod ranges specified here must have been specified earlier in the
    /// 'additional_pod_ranges_config' argument.
    pub removed_additional_pod_ranges_config:
        std::option::Option<crate::model::AdditionalPodRangesConfig>,

    /// Kubernetes open source beta apis enabled on the cluster. Only beta apis
    pub enable_k8s_beta_apis: std::option::Option<crate::model::K8sBetaAPIConfig>,

    /// Enable/Disable Security Posture API features for the cluster.
    pub desired_security_posture_config: std::option::Option<crate::model::SecurityPostureConfig>,

    /// The desired network performance config.
    pub desired_network_performance_config:
        std::option::Option<crate::model::network_config::ClusterNetworkPerformanceConfig>,

    /// Enable/Disable FQDN Network Policy for the cluster.
    pub desired_enable_fqdn_network_policy: std::option::Option<bool>,

    /// WorkloadPolicyConfig is the configuration related to GCW workload policy
    pub desired_autopilot_workload_policy_config:
        std::option::Option<crate::model::WorkloadPolicyConfig>,

    /// Desired Beta APIs to be enabled for cluster.
    pub desired_k8s_beta_apis: std::option::Option<crate::model::K8sBetaAPIConfig>,

    /// The desired containerd config for the cluster.
    pub desired_containerd_config: std::option::Option<crate::model::ContainerdConfig>,

    /// Enable/Disable Multi-Networking for the cluster
    pub desired_enable_multi_networking: std::option::Option<bool>,

    /// The desired resource manager tags that apply to all auto-provisioned node
    /// pools in autopilot clusters and node auto-provisioning enabled clusters.
    pub desired_node_pool_auto_config_resource_manager_tags:
        std::option::Option<crate::model::ResourceManagerTags>,

    /// Specify the details of in-transit encryption.
    pub desired_in_transit_encryption_config:
        std::option::Option<crate::model::InTransitEncryptionConfig>,

    /// Enable/Disable Cilium Clusterwide Network Policy for the cluster.
    pub desired_enable_cilium_clusterwide_network_policy: std::option::Option<bool>,

    /// Enable/Disable Secret Manager Config.
    pub desired_secret_manager_config: std::option::Option<crate::model::SecretManagerConfig>,

    /// Deprecated: Compliance Posture is no longer supported.
    /// For more details, see
    /// <https://cloud.google.com/kubernetes-engine/docs/deprecations/posture-management-deprecation>.
    ///
    /// Enable/Disable Compliance Posture features for the cluster.
    #[deprecated]
    pub desired_compliance_posture_config:
        std::option::Option<crate::model::CompliancePostureConfig>,

    /// The desired node kubelet config for the cluster.
    pub desired_node_kubelet_config: std::option::Option<crate::model::NodeKubeletConfig>,

    /// The desired node kubelet config for all auto-provisioned node pools
    /// in autopilot clusters and node auto-provisioning enabled clusters.
    pub desired_node_pool_auto_config_kubelet_config:
        std::option::Option<crate::model::NodeKubeletConfig>,

    /// The Custom keys configuration for the cluster.
    ///
    /// This field is deprecated.
    /// Use
    /// [ClusterUpdate.desired_user_managed_keys_config][google.container.v1.ClusterUpdate.desired_user_managed_keys_config]
    /// instead.
    ///
    /// [google.container.v1.ClusterUpdate.desired_user_managed_keys_config]: crate::model::ClusterUpdate::desired_user_managed_keys_config
    #[deprecated]
    pub user_managed_keys_config: std::option::Option<crate::model::UserManagedKeysConfig>,

    /// RBACBindingConfig allows user to restrict ClusterRoleBindings an
    /// RoleBindings that can be created.
    pub desired_rbac_binding_config: std::option::Option<crate::model::RBACBindingConfig>,

    /// The desired config for additional subnetworks attached to the cluster.
    pub desired_additional_ip_ranges_config:
        std::option::Option<crate::model::DesiredAdditionalIPRangesConfig>,

    /// The desired enterprise configuration for the cluster.
    ///
    /// Deprecated: GKE Enterprise features are now available without an Enterprise
    /// tier.
    #[deprecated]
    pub desired_enterprise_config: std::option::Option<crate::model::DesiredEnterpriseConfig>,

    /// AutoIpamConfig contains all information related to Auto IPAM
    pub desired_auto_ipam_config: std::option::Option<crate::model::AutoIpamConfig>,

    /// Enable/Disable L4 LB VPC firewall reconciliation for the cluster.
    pub desired_disable_l4_lb_firewall_reconciliation: std::option::Option<bool>,

    /// The desired Linux node config for all auto-provisioned node pools
    /// in autopilot clusters and node auto-provisioning enabled clusters.
    ///
    /// Currently only `cgroup_mode` can be set here.
    pub desired_node_pool_auto_config_linux_node_config:
        std::option::Option<crate::model::LinuxNodeConfig>,

    /// The desired user managed keys config for the cluster.
    pub desired_user_managed_keys_config: std::option::Option<crate::model::UserManagedKeysConfig>,

    /// Configuration for limiting anonymous access to all endpoints except the
    /// health checks.
    pub desired_anonymous_authentication_config:
        std::option::Option<crate::model::AnonymousAuthenticationConfig>,

    /// Configuration for GKE auto upgrade.
    pub gke_auto_upgrade_config: std::option::Option<crate::model::GkeAutoUpgradeConfig>,

    /// The desired network tier configuration for the cluster.
    pub desired_network_tier_config: std::option::Option<crate::model::NetworkTierConfig>,

    /// Configuration for sync Secret Manager secrets as k8s secrets.
    pub desired_secret_sync_config: std::option::Option<crate::model::SecretSyncConfig>,

    /// The desired privileged admission config for the cluster.
    pub desired_privileged_admission_config:
        std::option::Option<crate::model::PrivilegedAdmissionConfig>,

    /// The desired control plane egress control config for the cluster.
    pub desired_control_plane_egress: std::option::Option<crate::model::ControlPlaneEgress>,

    /// The desired managed open telemetry configuration.
    pub desired_managed_opentelemetry_config:
        std::option::Option<crate::model::ManagedOpenTelemetryConfig>,

    /// The desired autopilot cluster policies that to be enforced in the cluster.
    pub desired_autopilot_cluster_policy_config:
        std::option::Option<crate::model::ClusterPolicyConfig>,

    /// The desired managed machine learning diagnostics configuration.
    pub desired_managed_machine_learning_diagnostics_config:
        std::option::Option<crate::model::ManagedMachineLearningDiagnosticsConfig>,

    /// Optional. The desired NodeCreationConfig for the cluster.
    pub desired_node_creation_config: std::option::Option<crate::model::NodeCreationConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ClusterUpdate {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [desired_node_version][crate::model::ClusterUpdate::desired_node_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_node_version("example");
    /// ```
    pub fn set_desired_node_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_node_version = v.into();
        self
    }

    /// Sets the value of [desired_monitoring_service][crate::model::ClusterUpdate::desired_monitoring_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_monitoring_service("example");
    /// ```
    pub fn set_desired_monitoring_service<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_monitoring_service = v.into();
        self
    }

    /// Sets the value of [desired_addons_config][crate::model::ClusterUpdate::desired_addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = ClusterUpdate::new().set_desired_addons_config(AddonsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_addons_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.desired_addons_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_addons_config][crate::model::ClusterUpdate::desired_addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_addons_config(Some(AddonsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_addons_config(None::<AddonsConfig>);
    /// ```
    pub fn set_or_clear_desired_addons_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.desired_addons_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_id][crate::model::ClusterUpdate::desired_node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_node_pool_id("example");
    /// ```
    pub fn set_desired_node_pool_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_node_pool_id = v.into();
        self
    }

    /// Sets the value of [desired_image_type][crate::model::ClusterUpdate::desired_image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_image_type("example");
    /// ```
    pub fn set_desired_image_type<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_image_type = v.into();
        self
    }

    /// Sets the value of [desired_image][crate::model::ClusterUpdate::desired_image].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_image("example");
    /// ```
    pub fn set_desired_image<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.desired_image = v.into();
        self
    }

    /// Sets the value of [desired_image_project][crate::model::ClusterUpdate::desired_image_project].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_image_project("example");
    /// ```
    pub fn set_desired_image_project<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_image_project = v.into();
        self
    }

    /// Sets the value of [desired_database_encryption][crate::model::ClusterUpdate::desired_database_encryption].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = ClusterUpdate::new().set_desired_database_encryption(DatabaseEncryption::default()/* use setters */);
    /// ```
    pub fn set_desired_database_encryption<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DatabaseEncryption>,
    {
        self.desired_database_encryption = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_database_encryption][crate::model::ClusterUpdate::desired_database_encryption].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = ClusterUpdate::new().set_or_clear_desired_database_encryption(Some(DatabaseEncryption::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_database_encryption(None::<DatabaseEncryption>);
    /// ```
    pub fn set_or_clear_desired_database_encryption<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DatabaseEncryption>,
    {
        self.desired_database_encryption = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_workload_identity_config][crate::model::ClusterUpdate::desired_workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::WorkloadIdentityConfig;
    /// let x = ClusterUpdate::new().set_desired_workload_identity_config(WorkloadIdentityConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_workload_identity_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadIdentityConfig>,
    {
        self.desired_workload_identity_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_workload_identity_config][crate::model::ClusterUpdate::desired_workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::WorkloadIdentityConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_workload_identity_config(Some(WorkloadIdentityConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_workload_identity_config(None::<WorkloadIdentityConfig>);
    /// ```
    pub fn set_or_clear_desired_workload_identity_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadIdentityConfig>,
    {
        self.desired_workload_identity_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_mesh_certificates][crate::model::ClusterUpdate::desired_mesh_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MeshCertificates;
    /// let x = ClusterUpdate::new().set_desired_mesh_certificates(MeshCertificates::default()/* use setters */);
    /// ```
    pub fn set_desired_mesh_certificates<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MeshCertificates>,
    {
        self.desired_mesh_certificates = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_mesh_certificates][crate::model::ClusterUpdate::desired_mesh_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MeshCertificates;
    /// let x = ClusterUpdate::new().set_or_clear_desired_mesh_certificates(Some(MeshCertificates::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_mesh_certificates(None::<MeshCertificates>);
    /// ```
    pub fn set_or_clear_desired_mesh_certificates<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MeshCertificates>,
    {
        self.desired_mesh_certificates = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_shielded_nodes][crate::model::ClusterUpdate::desired_shielded_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ShieldedNodes;
    /// let x = ClusterUpdate::new().set_desired_shielded_nodes(ShieldedNodes::default()/* use setters */);
    /// ```
    pub fn set_desired_shielded_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedNodes>,
    {
        self.desired_shielded_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_shielded_nodes][crate::model::ClusterUpdate::desired_shielded_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ShieldedNodes;
    /// let x = ClusterUpdate::new().set_or_clear_desired_shielded_nodes(Some(ShieldedNodes::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_shielded_nodes(None::<ShieldedNodes>);
    /// ```
    pub fn set_or_clear_desired_shielded_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedNodes>,
    {
        self.desired_shielded_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_cost_management_config][crate::model::ClusterUpdate::desired_cost_management_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::CostManagementConfig;
    /// let x = ClusterUpdate::new().set_desired_cost_management_config(CostManagementConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_cost_management_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CostManagementConfig>,
    {
        self.desired_cost_management_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_cost_management_config][crate::model::ClusterUpdate::desired_cost_management_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::CostManagementConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_cost_management_config(Some(CostManagementConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_cost_management_config(None::<CostManagementConfig>);
    /// ```
    pub fn set_or_clear_desired_cost_management_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::CostManagementConfig>,
    {
        self.desired_cost_management_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_dns_config][crate::model::ClusterUpdate::desired_dns_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DNSConfig;
    /// let x = ClusterUpdate::new().set_desired_dns_config(DNSConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_dns_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DNSConfig>,
    {
        self.desired_dns_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_dns_config][crate::model::ClusterUpdate::desired_dns_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DNSConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_dns_config(Some(DNSConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_dns_config(None::<DNSConfig>);
    /// ```
    pub fn set_or_clear_desired_dns_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DNSConfig>,
    {
        self.desired_dns_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_autoscaling][crate::model::ClusterUpdate::desired_node_pool_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = ClusterUpdate::new().set_desired_node_pool_autoscaling(NodePoolAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.desired_node_pool_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_autoscaling][crate::model::ClusterUpdate::desired_node_pool_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_autoscaling(Some(NodePoolAutoscaling::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_autoscaling(None::<NodePoolAutoscaling>);
    /// ```
    pub fn set_or_clear_desired_node_pool_autoscaling<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.desired_node_pool_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_locations][crate::model::ClusterUpdate::desired_locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_locations(["a", "b", "c"]);
    /// ```
    pub fn set_desired_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.desired_locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [desired_master_authorized_networks_config][crate::model::ClusterUpdate::desired_master_authorized_networks_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = ClusterUpdate::new().set_desired_master_authorized_networks_config(MasterAuthorizedNetworksConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_desired_master_authorized_networks_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
    {
        self.desired_master_authorized_networks_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_master_authorized_networks_config][crate::model::ClusterUpdate::desired_master_authorized_networks_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_master_authorized_networks_config(Some(MasterAuthorizedNetworksConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_master_authorized_networks_config(None::<MasterAuthorizedNetworksConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_desired_master_authorized_networks_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
    {
        self.desired_master_authorized_networks_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_cluster_autoscaling][crate::model::ClusterUpdate::desired_cluster_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = ClusterUpdate::new().set_desired_cluster_autoscaling(ClusterAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_desired_cluster_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClusterAutoscaling>,
    {
        self.desired_cluster_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_cluster_autoscaling][crate::model::ClusterUpdate::desired_cluster_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = ClusterUpdate::new().set_or_clear_desired_cluster_autoscaling(Some(ClusterAutoscaling::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_cluster_autoscaling(None::<ClusterAutoscaling>);
    /// ```
    pub fn set_or_clear_desired_cluster_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ClusterAutoscaling>,
    {
        self.desired_cluster_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_binary_authorization][crate::model::ClusterUpdate::desired_binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::BinaryAuthorization;
    /// let x = ClusterUpdate::new().set_desired_binary_authorization(BinaryAuthorization::default()/* use setters */);
    /// ```
    pub fn set_desired_binary_authorization<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BinaryAuthorization>,
    {
        self.desired_binary_authorization = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_binary_authorization][crate::model::ClusterUpdate::desired_binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::BinaryAuthorization;
    /// let x = ClusterUpdate::new().set_or_clear_desired_binary_authorization(Some(BinaryAuthorization::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_binary_authorization(None::<BinaryAuthorization>);
    /// ```
    pub fn set_or_clear_desired_binary_authorization<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BinaryAuthorization>,
    {
        self.desired_binary_authorization = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_logging_service][crate::model::ClusterUpdate::desired_logging_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_logging_service("example");
    /// ```
    pub fn set_desired_logging_service<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_logging_service = v.into();
        self
    }

    /// Sets the value of [desired_resource_usage_export_config][crate::model::ClusterUpdate::desired_resource_usage_export_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// let x = ClusterUpdate::new().set_desired_resource_usage_export_config(ResourceUsageExportConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_resource_usage_export_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceUsageExportConfig>,
    {
        self.desired_resource_usage_export_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_resource_usage_export_config][crate::model::ClusterUpdate::desired_resource_usage_export_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_resource_usage_export_config(Some(ResourceUsageExportConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_resource_usage_export_config(None::<ResourceUsageExportConfig>);
    /// ```
    pub fn set_or_clear_desired_resource_usage_export_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ResourceUsageExportConfig>,
    {
        self.desired_resource_usage_export_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_vertical_pod_autoscaling][crate::model::ClusterUpdate::desired_vertical_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::VerticalPodAutoscaling;
    /// let x = ClusterUpdate::new().set_desired_vertical_pod_autoscaling(VerticalPodAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_desired_vertical_pod_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::VerticalPodAutoscaling>,
    {
        self.desired_vertical_pod_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_vertical_pod_autoscaling][crate::model::ClusterUpdate::desired_vertical_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::VerticalPodAutoscaling;
    /// let x = ClusterUpdate::new().set_or_clear_desired_vertical_pod_autoscaling(Some(VerticalPodAutoscaling::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_vertical_pod_autoscaling(None::<VerticalPodAutoscaling>);
    /// ```
    pub fn set_or_clear_desired_vertical_pod_autoscaling<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::VerticalPodAutoscaling>,
    {
        self.desired_vertical_pod_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_private_cluster_config][crate::model::ClusterUpdate::desired_private_cluster_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = ClusterUpdate::new().set_desired_private_cluster_config(PrivateClusterConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_desired_private_cluster_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterConfig>,
    {
        self.desired_private_cluster_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_private_cluster_config][crate::model::ClusterUpdate::desired_private_cluster_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PrivateClusterConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_private_cluster_config(Some(PrivateClusterConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_private_cluster_config(None::<PrivateClusterConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_desired_private_cluster_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::PrivateClusterConfig>,
    {
        self.desired_private_cluster_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_intra_node_visibility_config][crate::model::ClusterUpdate::desired_intra_node_visibility_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::IntraNodeVisibilityConfig;
    /// let x = ClusterUpdate::new().set_desired_intra_node_visibility_config(IntraNodeVisibilityConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_intra_node_visibility_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::IntraNodeVisibilityConfig>,
    {
        self.desired_intra_node_visibility_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_intra_node_visibility_config][crate::model::ClusterUpdate::desired_intra_node_visibility_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::IntraNodeVisibilityConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_intra_node_visibility_config(Some(IntraNodeVisibilityConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_intra_node_visibility_config(None::<IntraNodeVisibilityConfig>);
    /// ```
    pub fn set_or_clear_desired_intra_node_visibility_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::IntraNodeVisibilityConfig>,
    {
        self.desired_intra_node_visibility_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_default_snat_status][crate::model::ClusterUpdate::desired_default_snat_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DefaultSnatStatus;
    /// let x = ClusterUpdate::new().set_desired_default_snat_status(DefaultSnatStatus::default()/* use setters */);
    /// ```
    pub fn set_desired_default_snat_status<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DefaultSnatStatus>,
    {
        self.desired_default_snat_status = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_default_snat_status][crate::model::ClusterUpdate::desired_default_snat_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DefaultSnatStatus;
    /// let x = ClusterUpdate::new().set_or_clear_desired_default_snat_status(Some(DefaultSnatStatus::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_default_snat_status(None::<DefaultSnatStatus>);
    /// ```
    pub fn set_or_clear_desired_default_snat_status<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DefaultSnatStatus>,
    {
        self.desired_default_snat_status = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_release_channel][crate::model::ClusterUpdate::desired_release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = ClusterUpdate::new().set_desired_release_channel(ReleaseChannel::default()/* use setters */);
    /// ```
    pub fn set_desired_release_channel<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.desired_release_channel = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_release_channel][crate::model::ClusterUpdate::desired_release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = ClusterUpdate::new().set_or_clear_desired_release_channel(Some(ReleaseChannel::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_release_channel(None::<ReleaseChannel>);
    /// ```
    pub fn set_or_clear_desired_release_channel<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.desired_release_channel = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_l4ilb_subsetting_config][crate::model::ClusterUpdate::desired_l4ilb_subsetting_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ILBSubsettingConfig;
    /// let x = ClusterUpdate::new().set_desired_l4ilb_subsetting_config(ILBSubsettingConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_l4ilb_subsetting_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ILBSubsettingConfig>,
    {
        self.desired_l4ilb_subsetting_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_l4ilb_subsetting_config][crate::model::ClusterUpdate::desired_l4ilb_subsetting_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ILBSubsettingConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_l4ilb_subsetting_config(Some(ILBSubsettingConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_l4ilb_subsetting_config(None::<ILBSubsettingConfig>);
    /// ```
    pub fn set_or_clear_desired_l4ilb_subsetting_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ILBSubsettingConfig>,
    {
        self.desired_l4ilb_subsetting_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_datapath_provider][crate::model::ClusterUpdate::desired_datapath_provider].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DatapathProvider;
    /// let x0 = ClusterUpdate::new().set_desired_datapath_provider(DatapathProvider::LegacyDatapath);
    /// let x1 = ClusterUpdate::new().set_desired_datapath_provider(DatapathProvider::AdvancedDatapath);
    /// ```
    pub fn set_desired_datapath_provider<T: std::convert::Into<crate::model::DatapathProvider>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_datapath_provider = v.into();
        self
    }

    /// Sets the value of [desired_private_ipv6_google_access][crate::model::ClusterUpdate::desired_private_ipv6_google_access].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PrivateIPv6GoogleAccess;
    /// let x0 = ClusterUpdate::new().set_desired_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessDisabled);
    /// let x1 = ClusterUpdate::new().set_desired_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessToGoogle);
    /// let x2 = ClusterUpdate::new().set_desired_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessBidirectional);
    /// ```
    pub fn set_desired_private_ipv6_google_access<
        T: std::convert::Into<crate::model::PrivateIPv6GoogleAccess>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.desired_private_ipv6_google_access = v.into();
        self
    }

    /// Sets the value of [desired_notification_config][crate::model::ClusterUpdate::desired_notification_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NotificationConfig;
    /// let x = ClusterUpdate::new().set_desired_notification_config(NotificationConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_notification_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NotificationConfig>,
    {
        self.desired_notification_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_notification_config][crate::model::ClusterUpdate::desired_notification_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NotificationConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_notification_config(Some(NotificationConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_notification_config(None::<NotificationConfig>);
    /// ```
    pub fn set_or_clear_desired_notification_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NotificationConfig>,
    {
        self.desired_notification_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_authenticator_groups_config][crate::model::ClusterUpdate::desired_authenticator_groups_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = ClusterUpdate::new().set_desired_authenticator_groups_config(AuthenticatorGroupsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_authenticator_groups_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AuthenticatorGroupsConfig>,
    {
        self.desired_authenticator_groups_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_authenticator_groups_config][crate::model::ClusterUpdate::desired_authenticator_groups_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AuthenticatorGroupsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_authenticator_groups_config(Some(AuthenticatorGroupsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_authenticator_groups_config(None::<AuthenticatorGroupsConfig>);
    /// ```
    pub fn set_or_clear_desired_authenticator_groups_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AuthenticatorGroupsConfig>,
    {
        self.desired_authenticator_groups_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_logging_config][crate::model::ClusterUpdate::desired_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::LoggingConfig;
    /// let x = ClusterUpdate::new().set_desired_logging_config(LoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LoggingConfig>,
    {
        self.desired_logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_logging_config][crate::model::ClusterUpdate::desired_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::LoggingConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_logging_config(Some(LoggingConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_logging_config(None::<LoggingConfig>);
    /// ```
    pub fn set_or_clear_desired_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LoggingConfig>,
    {
        self.desired_logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_monitoring_config][crate::model::ClusterUpdate::desired_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MonitoringConfig;
    /// let x = ClusterUpdate::new().set_desired_monitoring_config(MonitoringConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_monitoring_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringConfig>,
    {
        self.desired_monitoring_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_monitoring_config][crate::model::ClusterUpdate::desired_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::MonitoringConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_monitoring_config(Some(MonitoringConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_monitoring_config(None::<MonitoringConfig>);
    /// ```
    pub fn set_or_clear_desired_monitoring_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringConfig>,
    {
        self.desired_monitoring_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_identity_service_config][crate::model::ClusterUpdate::desired_identity_service_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::IdentityServiceConfig;
    /// let x = ClusterUpdate::new().set_desired_identity_service_config(IdentityServiceConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_identity_service_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::IdentityServiceConfig>,
    {
        self.desired_identity_service_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_identity_service_config][crate::model::ClusterUpdate::desired_identity_service_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::IdentityServiceConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_identity_service_config(Some(IdentityServiceConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_identity_service_config(None::<IdentityServiceConfig>);
    /// ```
    pub fn set_or_clear_desired_identity_service_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::IdentityServiceConfig>,
    {
        self.desired_identity_service_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_service_external_ips_config][crate::model::ClusterUpdate::desired_service_external_ips_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ServiceExternalIPsConfig;
    /// let x = ClusterUpdate::new().set_desired_service_external_ips_config(ServiceExternalIPsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_service_external_ips_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ServiceExternalIPsConfig>,
    {
        self.desired_service_external_ips_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_service_external_ips_config][crate::model::ClusterUpdate::desired_service_external_ips_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ServiceExternalIPsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_service_external_ips_config(Some(ServiceExternalIPsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_service_external_ips_config(None::<ServiceExternalIPsConfig>);
    /// ```
    pub fn set_or_clear_desired_service_external_ips_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ServiceExternalIPsConfig>,
    {
        self.desired_service_external_ips_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_enable_private_endpoint][crate::model::ClusterUpdate::desired_enable_private_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_enable_private_endpoint(true);
    /// ```
    #[deprecated]
    pub fn set_desired_enable_private_endpoint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_private_endpoint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_enable_private_endpoint][crate::model::ClusterUpdate::desired_enable_private_endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_private_endpoint(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_private_endpoint(None::<bool>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_desired_enable_private_endpoint<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_private_endpoint = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_default_enable_private_nodes][crate::model::ClusterUpdate::desired_default_enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_default_enable_private_nodes(true);
    /// ```
    pub fn set_desired_default_enable_private_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_default_enable_private_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_default_enable_private_nodes][crate::model::ClusterUpdate::desired_default_enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_default_enable_private_nodes(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_default_enable_private_nodes(None::<bool>);
    /// ```
    pub fn set_or_clear_desired_default_enable_private_nodes<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_default_enable_private_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_control_plane_endpoints_config][crate::model::ClusterUpdate::desired_control_plane_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// let x = ClusterUpdate::new().set_desired_control_plane_endpoints_config(ControlPlaneEndpointsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_control_plane_endpoints_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEndpointsConfig>,
    {
        self.desired_control_plane_endpoints_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_control_plane_endpoints_config][crate::model::ClusterUpdate::desired_control_plane_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_control_plane_endpoints_config(Some(ControlPlaneEndpointsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_control_plane_endpoints_config(None::<ControlPlaneEndpointsConfig>);
    /// ```
    pub fn set_or_clear_desired_control_plane_endpoints_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEndpointsConfig>,
    {
        self.desired_control_plane_endpoints_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_master_version][crate::model::ClusterUpdate::desired_master_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_master_version("example");
    /// ```
    pub fn set_desired_master_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_master_version = v.into();
        self
    }

    /// Sets the value of [desired_gcfs_config][crate::model::ClusterUpdate::desired_gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = ClusterUpdate::new().set_desired_gcfs_config(GcfsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_gcfs_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.desired_gcfs_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_gcfs_config][crate::model::ClusterUpdate::desired_gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_gcfs_config(Some(GcfsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_gcfs_config(None::<GcfsConfig>);
    /// ```
    pub fn set_or_clear_desired_gcfs_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.desired_gcfs_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_auto_config_network_tags][crate::model::ClusterUpdate::desired_node_pool_auto_config_network_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = ClusterUpdate::new().set_desired_node_pool_auto_config_network_tags(NetworkTags::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_auto_config_network_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.desired_node_pool_auto_config_network_tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_auto_config_network_tags][crate::model::ClusterUpdate::desired_node_pool_auto_config_network_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_network_tags(Some(NetworkTags::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_network_tags(None::<NetworkTags>);
    /// ```
    pub fn set_or_clear_desired_node_pool_auto_config_network_tags<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.desired_node_pool_auto_config_network_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_pod_autoscaling][crate::model::ClusterUpdate::desired_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PodAutoscaling;
    /// let x = ClusterUpdate::new().set_desired_pod_autoscaling(PodAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_desired_pod_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PodAutoscaling>,
    {
        self.desired_pod_autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_pod_autoscaling][crate::model::ClusterUpdate::desired_pod_autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PodAutoscaling;
    /// let x = ClusterUpdate::new().set_or_clear_desired_pod_autoscaling(Some(PodAutoscaling::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_pod_autoscaling(None::<PodAutoscaling>);
    /// ```
    pub fn set_or_clear_desired_pod_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PodAutoscaling>,
    {
        self.desired_pod_autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_gateway_api_config][crate::model::ClusterUpdate::desired_gateway_api_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GatewayAPIConfig;
    /// let x = ClusterUpdate::new().set_desired_gateway_api_config(GatewayAPIConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_gateway_api_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GatewayAPIConfig>,
    {
        self.desired_gateway_api_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_gateway_api_config][crate::model::ClusterUpdate::desired_gateway_api_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GatewayAPIConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_gateway_api_config(Some(GatewayAPIConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_gateway_api_config(None::<GatewayAPIConfig>);
    /// ```
    pub fn set_or_clear_desired_gateway_api_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GatewayAPIConfig>,
    {
        self.desired_gateway_api_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [etag][crate::model::ClusterUpdate::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }

    /// Sets the value of [desired_node_pool_logging_config][crate::model::ClusterUpdate::desired_node_pool_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = ClusterUpdate::new().set_desired_node_pool_logging_config(NodePoolLoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.desired_node_pool_logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_logging_config][crate::model::ClusterUpdate::desired_node_pool_logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_logging_config(Some(NodePoolLoggingConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_logging_config(None::<NodePoolLoggingConfig>);
    /// ```
    pub fn set_or_clear_desired_node_pool_logging_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.desired_node_pool_logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_fleet][crate::model::ClusterUpdate::desired_fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::Fleet;
    /// let x = ClusterUpdate::new().set_desired_fleet(Fleet::default()/* use setters */);
    /// ```
    pub fn set_desired_fleet<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Fleet>,
    {
        self.desired_fleet = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_fleet][crate::model::ClusterUpdate::desired_fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::Fleet;
    /// let x = ClusterUpdate::new().set_or_clear_desired_fleet(Some(Fleet::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_fleet(None::<Fleet>);
    /// ```
    pub fn set_or_clear_desired_fleet<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Fleet>,
    {
        self.desired_fleet = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_stack_type][crate::model::ClusterUpdate::desired_stack_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::StackType;
    /// let x0 = ClusterUpdate::new().set_desired_stack_type(StackType::Ipv4);
    /// let x1 = ClusterUpdate::new().set_desired_stack_type(StackType::Ipv4Ipv6);
    /// ```
    pub fn set_desired_stack_type<T: std::convert::Into<crate::model::StackType>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_stack_type = v.into();
        self
    }

    /// Sets the value of [additional_pod_ranges_config][crate::model::ClusterUpdate::additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = ClusterUpdate::new().set_additional_pod_ranges_config(AdditionalPodRangesConfig::default()/* use setters */);
    /// ```
    pub fn set_additional_pod_ranges_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.additional_pod_ranges_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [additional_pod_ranges_config][crate::model::ClusterUpdate::additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = ClusterUpdate::new().set_or_clear_additional_pod_ranges_config(Some(AdditionalPodRangesConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_additional_pod_ranges_config(None::<AdditionalPodRangesConfig>);
    /// ```
    pub fn set_or_clear_additional_pod_ranges_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.additional_pod_ranges_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [removed_additional_pod_ranges_config][crate::model::ClusterUpdate::removed_additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = ClusterUpdate::new().set_removed_additional_pod_ranges_config(AdditionalPodRangesConfig::default()/* use setters */);
    /// ```
    pub fn set_removed_additional_pod_ranges_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.removed_additional_pod_ranges_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [removed_additional_pod_ranges_config][crate::model::ClusterUpdate::removed_additional_pod_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = ClusterUpdate::new().set_or_clear_removed_additional_pod_ranges_config(Some(AdditionalPodRangesConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_removed_additional_pod_ranges_config(None::<AdditionalPodRangesConfig>);
    /// ```
    pub fn set_or_clear_removed_additional_pod_ranges_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AdditionalPodRangesConfig>,
    {
        self.removed_additional_pod_ranges_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_k8s_beta_apis][crate::model::ClusterUpdate::enable_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = ClusterUpdate::new().set_enable_k8s_beta_apis(K8sBetaAPIConfig::default()/* use setters */);
    /// ```
    pub fn set_enable_k8s_beta_apis<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.enable_k8s_beta_apis = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_k8s_beta_apis][crate::model::ClusterUpdate::enable_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = ClusterUpdate::new().set_or_clear_enable_k8s_beta_apis(Some(K8sBetaAPIConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_enable_k8s_beta_apis(None::<K8sBetaAPIConfig>);
    /// ```
    pub fn set_or_clear_enable_k8s_beta_apis<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.enable_k8s_beta_apis = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_security_posture_config][crate::model::ClusterUpdate::desired_security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecurityPostureConfig;
    /// let x = ClusterUpdate::new().set_desired_security_posture_config(SecurityPostureConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_security_posture_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecurityPostureConfig>,
    {
        self.desired_security_posture_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_security_posture_config][crate::model::ClusterUpdate::desired_security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecurityPostureConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_security_posture_config(Some(SecurityPostureConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_security_posture_config(None::<SecurityPostureConfig>);
    /// ```
    pub fn set_or_clear_desired_security_posture_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::SecurityPostureConfig>,
    {
        self.desired_security_posture_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_network_performance_config][crate::model::ClusterUpdate::desired_network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
    /// let x = ClusterUpdate::new().set_desired_network_performance_config(ClusterNetworkPerformanceConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_network_performance_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::network_config::ClusterNetworkPerformanceConfig>,
    {
        self.desired_network_performance_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_network_performance_config][crate::model::ClusterUpdate::desired_network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_network_performance_config(Some(ClusterNetworkPerformanceConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_network_performance_config(None::<ClusterNetworkPerformanceConfig>);
    /// ```
    pub fn set_or_clear_desired_network_performance_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::network_config::ClusterNetworkPerformanceConfig>,
    {
        self.desired_network_performance_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_enable_fqdn_network_policy][crate::model::ClusterUpdate::desired_enable_fqdn_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_enable_fqdn_network_policy(true);
    /// ```
    pub fn set_desired_enable_fqdn_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_fqdn_network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_enable_fqdn_network_policy][crate::model::ClusterUpdate::desired_enable_fqdn_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_fqdn_network_policy(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_fqdn_network_policy(None::<bool>);
    /// ```
    pub fn set_or_clear_desired_enable_fqdn_network_policy<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_fqdn_network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_autopilot_workload_policy_config][crate::model::ClusterUpdate::desired_autopilot_workload_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = ClusterUpdate::new().set_desired_autopilot_workload_policy_config(WorkloadPolicyConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_autopilot_workload_policy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadPolicyConfig>,
    {
        self.desired_autopilot_workload_policy_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_autopilot_workload_policy_config][crate::model::ClusterUpdate::desired_autopilot_workload_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_autopilot_workload_policy_config(Some(WorkloadPolicyConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_autopilot_workload_policy_config(None::<WorkloadPolicyConfig>);
    /// ```
    pub fn set_or_clear_desired_autopilot_workload_policy_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadPolicyConfig>,
    {
        self.desired_autopilot_workload_policy_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_k8s_beta_apis][crate::model::ClusterUpdate::desired_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = ClusterUpdate::new().set_desired_k8s_beta_apis(K8sBetaAPIConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_k8s_beta_apis<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.desired_k8s_beta_apis = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_k8s_beta_apis][crate::model::ClusterUpdate::desired_k8s_beta_apis].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::K8sBetaAPIConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_k8s_beta_apis(Some(K8sBetaAPIConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_k8s_beta_apis(None::<K8sBetaAPIConfig>);
    /// ```
    pub fn set_or_clear_desired_k8s_beta_apis<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::K8sBetaAPIConfig>,
    {
        self.desired_k8s_beta_apis = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_containerd_config][crate::model::ClusterUpdate::desired_containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = ClusterUpdate::new().set_desired_containerd_config(ContainerdConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_containerd_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.desired_containerd_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_containerd_config][crate::model::ClusterUpdate::desired_containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_containerd_config(Some(ContainerdConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_containerd_config(None::<ContainerdConfig>);
    /// ```
    pub fn set_or_clear_desired_containerd_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.desired_containerd_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_enable_multi_networking][crate::model::ClusterUpdate::desired_enable_multi_networking].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_enable_multi_networking(true);
    /// ```
    pub fn set_desired_enable_multi_networking<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_multi_networking = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_enable_multi_networking][crate::model::ClusterUpdate::desired_enable_multi_networking].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_multi_networking(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_multi_networking(None::<bool>);
    /// ```
    pub fn set_or_clear_desired_enable_multi_networking<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_multi_networking = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_auto_config_resource_manager_tags][crate::model::ClusterUpdate::desired_node_pool_auto_config_resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = ClusterUpdate::new().set_desired_node_pool_auto_config_resource_manager_tags(ResourceManagerTags::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_auto_config_resource_manager_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.desired_node_pool_auto_config_resource_manager_tags =
            std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_auto_config_resource_manager_tags][crate::model::ClusterUpdate::desired_node_pool_auto_config_resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_resource_manager_tags(Some(ResourceManagerTags::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_resource_manager_tags(None::<ResourceManagerTags>);
    /// ```
    pub fn set_or_clear_desired_node_pool_auto_config_resource_manager_tags<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.desired_node_pool_auto_config_resource_manager_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_in_transit_encryption_config][crate::model::ClusterUpdate::desired_in_transit_encryption_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::InTransitEncryptionConfig;
    /// let x0 = ClusterUpdate::new().set_desired_in_transit_encryption_config(InTransitEncryptionConfig::InTransitEncryptionDisabled);
    /// let x1 = ClusterUpdate::new().set_desired_in_transit_encryption_config(InTransitEncryptionConfig::InTransitEncryptionInterNodeTransparent);
    /// ```
    pub fn set_desired_in_transit_encryption_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::InTransitEncryptionConfig>,
    {
        self.desired_in_transit_encryption_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_in_transit_encryption_config][crate::model::ClusterUpdate::desired_in_transit_encryption_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::InTransitEncryptionConfig;
    /// let x0 = ClusterUpdate::new().set_or_clear_desired_in_transit_encryption_config(Some(InTransitEncryptionConfig::InTransitEncryptionDisabled));
    /// let x1 = ClusterUpdate::new().set_or_clear_desired_in_transit_encryption_config(Some(InTransitEncryptionConfig::InTransitEncryptionInterNodeTransparent));
    /// let x_none = ClusterUpdate::new().set_or_clear_desired_in_transit_encryption_config(None::<InTransitEncryptionConfig>);
    /// ```
    pub fn set_or_clear_desired_in_transit_encryption_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::InTransitEncryptionConfig>,
    {
        self.desired_in_transit_encryption_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_enable_cilium_clusterwide_network_policy][crate::model::ClusterUpdate::desired_enable_cilium_clusterwide_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_enable_cilium_clusterwide_network_policy(true);
    /// ```
    pub fn set_desired_enable_cilium_clusterwide_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_cilium_clusterwide_network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_enable_cilium_clusterwide_network_policy][crate::model::ClusterUpdate::desired_enable_cilium_clusterwide_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_cilium_clusterwide_network_policy(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_enable_cilium_clusterwide_network_policy(None::<bool>);
    /// ```
    pub fn set_or_clear_desired_enable_cilium_clusterwide_network_policy<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_enable_cilium_clusterwide_network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_secret_manager_config][crate::model::ClusterUpdate::desired_secret_manager_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = ClusterUpdate::new().set_desired_secret_manager_config(SecretManagerConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_secret_manager_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecretManagerConfig>,
    {
        self.desired_secret_manager_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_secret_manager_config][crate::model::ClusterUpdate::desired_secret_manager_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_secret_manager_config(Some(SecretManagerConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_secret_manager_config(None::<SecretManagerConfig>);
    /// ```
    pub fn set_or_clear_desired_secret_manager_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::SecretManagerConfig>,
    {
        self.desired_secret_manager_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_compliance_posture_config][crate::model::ClusterUpdate::desired_compliance_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::CompliancePostureConfig;
    /// let x = ClusterUpdate::new().set_desired_compliance_posture_config(CompliancePostureConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_desired_compliance_posture_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CompliancePostureConfig>,
    {
        self.desired_compliance_posture_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_compliance_posture_config][crate::model::ClusterUpdate::desired_compliance_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::CompliancePostureConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_compliance_posture_config(Some(CompliancePostureConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_compliance_posture_config(None::<CompliancePostureConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_desired_compliance_posture_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::CompliancePostureConfig>,
    {
        self.desired_compliance_posture_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_kubelet_config][crate::model::ClusterUpdate::desired_node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = ClusterUpdate::new().set_desired_node_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_node_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.desired_node_kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_kubelet_config][crate::model::ClusterUpdate::desired_node_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_desired_node_kubelet_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.desired_node_kubelet_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_auto_config_kubelet_config][crate::model::ClusterUpdate::desired_node_pool_auto_config_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = ClusterUpdate::new().set_desired_node_pool_auto_config_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_auto_config_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.desired_node_pool_auto_config_kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_auto_config_kubelet_config][crate::model::ClusterUpdate::desired_node_pool_auto_config_kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_desired_node_pool_auto_config_kubelet_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.desired_node_pool_auto_config_kubelet_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [user_managed_keys_config][crate::model::ClusterUpdate::user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = ClusterUpdate::new().set_user_managed_keys_config(UserManagedKeysConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_user_managed_keys_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.user_managed_keys_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [user_managed_keys_config][crate::model::ClusterUpdate::user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = ClusterUpdate::new().set_or_clear_user_managed_keys_config(Some(UserManagedKeysConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_user_managed_keys_config(None::<UserManagedKeysConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_user_managed_keys_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.user_managed_keys_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_rbac_binding_config][crate::model::ClusterUpdate::desired_rbac_binding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = ClusterUpdate::new().set_desired_rbac_binding_config(RBACBindingConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_rbac_binding_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::RBACBindingConfig>,
    {
        self.desired_rbac_binding_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_rbac_binding_config][crate::model::ClusterUpdate::desired_rbac_binding_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::RBACBindingConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_rbac_binding_config(Some(RBACBindingConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_rbac_binding_config(None::<RBACBindingConfig>);
    /// ```
    pub fn set_or_clear_desired_rbac_binding_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::RBACBindingConfig>,
    {
        self.desired_rbac_binding_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_additional_ip_ranges_config][crate::model::ClusterUpdate::desired_additional_ip_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DesiredAdditionalIPRangesConfig;
    /// let x = ClusterUpdate::new().set_desired_additional_ip_ranges_config(DesiredAdditionalIPRangesConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_additional_ip_ranges_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DesiredAdditionalIPRangesConfig>,
    {
        self.desired_additional_ip_ranges_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_additional_ip_ranges_config][crate::model::ClusterUpdate::desired_additional_ip_ranges_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DesiredAdditionalIPRangesConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_additional_ip_ranges_config(Some(DesiredAdditionalIPRangesConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_additional_ip_ranges_config(None::<DesiredAdditionalIPRangesConfig>);
    /// ```
    pub fn set_or_clear_desired_additional_ip_ranges_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::DesiredAdditionalIPRangesConfig>,
    {
        self.desired_additional_ip_ranges_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_enterprise_config][crate::model::ClusterUpdate::desired_enterprise_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DesiredEnterpriseConfig;
    /// let x = ClusterUpdate::new().set_desired_enterprise_config(DesiredEnterpriseConfig::default()/* use setters */);
    /// ```
    #[deprecated]
    pub fn set_desired_enterprise_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DesiredEnterpriseConfig>,
    {
        self.desired_enterprise_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_enterprise_config][crate::model::ClusterUpdate::desired_enterprise_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::DesiredEnterpriseConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_enterprise_config(Some(DesiredEnterpriseConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_enterprise_config(None::<DesiredEnterpriseConfig>);
    /// ```
    #[deprecated]
    pub fn set_or_clear_desired_enterprise_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DesiredEnterpriseConfig>,
    {
        self.desired_enterprise_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_auto_ipam_config][crate::model::ClusterUpdate::desired_auto_ipam_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = ClusterUpdate::new().set_desired_auto_ipam_config(AutoIpamConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_auto_ipam_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AutoIpamConfig>,
    {
        self.desired_auto_ipam_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_auto_ipam_config][crate::model::ClusterUpdate::desired_auto_ipam_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_auto_ipam_config(Some(AutoIpamConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_auto_ipam_config(None::<AutoIpamConfig>);
    /// ```
    pub fn set_or_clear_desired_auto_ipam_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AutoIpamConfig>,
    {
        self.desired_auto_ipam_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_disable_l4_lb_firewall_reconciliation][crate::model::ClusterUpdate::desired_disable_l4_lb_firewall_reconciliation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_desired_disable_l4_lb_firewall_reconciliation(true);
    /// ```
    pub fn set_desired_disable_l4_lb_firewall_reconciliation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_disable_l4_lb_firewall_reconciliation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_disable_l4_lb_firewall_reconciliation][crate::model::ClusterUpdate::desired_disable_l4_lb_firewall_reconciliation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = ClusterUpdate::new().set_or_clear_desired_disable_l4_lb_firewall_reconciliation(Some(false));
    /// let x = ClusterUpdate::new().set_or_clear_desired_disable_l4_lb_firewall_reconciliation(None::<bool>);
    /// ```
    pub fn set_or_clear_desired_disable_l4_lb_firewall_reconciliation<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.desired_disable_l4_lb_firewall_reconciliation = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_pool_auto_config_linux_node_config][crate::model::ClusterUpdate::desired_node_pool_auto_config_linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = ClusterUpdate::new().set_desired_node_pool_auto_config_linux_node_config(LinuxNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_node_pool_auto_config_linux_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.desired_node_pool_auto_config_linux_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_pool_auto_config_linux_node_config][crate::model::ClusterUpdate::desired_node_pool_auto_config_linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_linux_node_config(Some(LinuxNodeConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_pool_auto_config_linux_node_config(None::<LinuxNodeConfig>);
    /// ```
    pub fn set_or_clear_desired_node_pool_auto_config_linux_node_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.desired_node_pool_auto_config_linux_node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_user_managed_keys_config][crate::model::ClusterUpdate::desired_user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = ClusterUpdate::new().set_desired_user_managed_keys_config(UserManagedKeysConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_user_managed_keys_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.desired_user_managed_keys_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_user_managed_keys_config][crate::model::ClusterUpdate::desired_user_managed_keys_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::UserManagedKeysConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_user_managed_keys_config(Some(UserManagedKeysConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_user_managed_keys_config(None::<UserManagedKeysConfig>);
    /// ```
    pub fn set_or_clear_desired_user_managed_keys_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::UserManagedKeysConfig>,
    {
        self.desired_user_managed_keys_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_anonymous_authentication_config][crate::model::ClusterUpdate::desired_anonymous_authentication_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AnonymousAuthenticationConfig;
    /// let x = ClusterUpdate::new().set_desired_anonymous_authentication_config(AnonymousAuthenticationConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_anonymous_authentication_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AnonymousAuthenticationConfig>,
    {
        self.desired_anonymous_authentication_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_anonymous_authentication_config][crate::model::ClusterUpdate::desired_anonymous_authentication_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::AnonymousAuthenticationConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_anonymous_authentication_config(Some(AnonymousAuthenticationConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_anonymous_authentication_config(None::<AnonymousAuthenticationConfig>);
    /// ```
    pub fn set_or_clear_desired_anonymous_authentication_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AnonymousAuthenticationConfig>,
    {
        self.desired_anonymous_authentication_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gke_auto_upgrade_config][crate::model::ClusterUpdate::gke_auto_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GkeAutoUpgradeConfig;
    /// let x = ClusterUpdate::new().set_gke_auto_upgrade_config(GkeAutoUpgradeConfig::default()/* use setters */);
    /// ```
    pub fn set_gke_auto_upgrade_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GkeAutoUpgradeConfig>,
    {
        self.gke_auto_upgrade_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gke_auto_upgrade_config][crate::model::ClusterUpdate::gke_auto_upgrade_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::GkeAutoUpgradeConfig;
    /// let x = ClusterUpdate::new().set_or_clear_gke_auto_upgrade_config(Some(GkeAutoUpgradeConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_gke_auto_upgrade_config(None::<GkeAutoUpgradeConfig>);
    /// ```
    pub fn set_or_clear_gke_auto_upgrade_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GkeAutoUpgradeConfig>,
    {
        self.gke_auto_upgrade_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_network_tier_config][crate::model::ClusterUpdate::desired_network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = ClusterUpdate::new().set_desired_network_tier_config(NetworkTierConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_network_tier_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.desired_network_tier_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_network_tier_config][crate::model::ClusterUpdate::desired_network_tier_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NetworkTierConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_network_tier_config(Some(NetworkTierConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_network_tier_config(None::<NetworkTierConfig>);
    /// ```
    pub fn set_or_clear_desired_network_tier_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTierConfig>,
    {
        self.desired_network_tier_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_secret_sync_config][crate::model::ClusterUpdate::desired_secret_sync_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = ClusterUpdate::new().set_desired_secret_sync_config(SecretSyncConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_secret_sync_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::SecretSyncConfig>,
    {
        self.desired_secret_sync_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_secret_sync_config][crate::model::ClusterUpdate::desired_secret_sync_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_secret_sync_config(Some(SecretSyncConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_secret_sync_config(None::<SecretSyncConfig>);
    /// ```
    pub fn set_or_clear_desired_secret_sync_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::SecretSyncConfig>,
    {
        self.desired_secret_sync_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_privileged_admission_config][crate::model::ClusterUpdate::desired_privileged_admission_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PrivilegedAdmissionConfig;
    /// let x = ClusterUpdate::new().set_desired_privileged_admission_config(PrivilegedAdmissionConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_privileged_admission_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PrivilegedAdmissionConfig>,
    {
        self.desired_privileged_admission_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_privileged_admission_config][crate::model::ClusterUpdate::desired_privileged_admission_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::PrivilegedAdmissionConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_privileged_admission_config(Some(PrivilegedAdmissionConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_privileged_admission_config(None::<PrivilegedAdmissionConfig>);
    /// ```
    pub fn set_or_clear_desired_privileged_admission_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::PrivilegedAdmissionConfig>,
    {
        self.desired_privileged_admission_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_control_plane_egress][crate::model::ClusterUpdate::desired_control_plane_egress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ControlPlaneEgress;
    /// let x = ClusterUpdate::new().set_desired_control_plane_egress(ControlPlaneEgress::default()/* use setters */);
    /// ```
    pub fn set_desired_control_plane_egress<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEgress>,
    {
        self.desired_control_plane_egress = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_control_plane_egress][crate::model::ClusterUpdate::desired_control_plane_egress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ControlPlaneEgress;
    /// let x = ClusterUpdate::new().set_or_clear_desired_control_plane_egress(Some(ControlPlaneEgress::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_control_plane_egress(None::<ControlPlaneEgress>);
    /// ```
    pub fn set_or_clear_desired_control_plane_egress<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ControlPlaneEgress>,
    {
        self.desired_control_plane_egress = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_managed_opentelemetry_config][crate::model::ClusterUpdate::desired_managed_opentelemetry_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// let x = ClusterUpdate::new().set_desired_managed_opentelemetry_config(ManagedOpenTelemetryConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_managed_opentelemetry_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ManagedOpenTelemetryConfig>,
    {
        self.desired_managed_opentelemetry_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_managed_opentelemetry_config][crate::model::ClusterUpdate::desired_managed_opentelemetry_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_managed_opentelemetry_config(Some(ManagedOpenTelemetryConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_managed_opentelemetry_config(None::<ManagedOpenTelemetryConfig>);
    /// ```
    pub fn set_or_clear_desired_managed_opentelemetry_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ManagedOpenTelemetryConfig>,
    {
        self.desired_managed_opentelemetry_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_autopilot_cluster_policy_config][crate::model::ClusterUpdate::desired_autopilot_cluster_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterUpdate::new().set_desired_autopilot_cluster_policy_config(ClusterPolicyConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_autopilot_cluster_policy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClusterPolicyConfig>,
    {
        self.desired_autopilot_cluster_policy_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_autopilot_cluster_policy_config][crate::model::ClusterUpdate::desired_autopilot_cluster_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_autopilot_cluster_policy_config(Some(ClusterPolicyConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_autopilot_cluster_policy_config(None::<ClusterPolicyConfig>);
    /// ```
    pub fn set_or_clear_desired_autopilot_cluster_policy_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ClusterPolicyConfig>,
    {
        self.desired_autopilot_cluster_policy_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_managed_machine_learning_diagnostics_config][crate::model::ClusterUpdate::desired_managed_machine_learning_diagnostics_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = ClusterUpdate::new().set_desired_managed_machine_learning_diagnostics_config(ManagedMachineLearningDiagnosticsConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_managed_machine_learning_diagnostics_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ManagedMachineLearningDiagnosticsConfig>,
    {
        self.desired_managed_machine_learning_diagnostics_config =
            std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_managed_machine_learning_diagnostics_config][crate::model::ClusterUpdate::desired_managed_machine_learning_diagnostics_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_managed_machine_learning_diagnostics_config(Some(ManagedMachineLearningDiagnosticsConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_managed_machine_learning_diagnostics_config(None::<ManagedMachineLearningDiagnosticsConfig>);
    /// ```
    pub fn set_or_clear_desired_managed_machine_learning_diagnostics_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::ManagedMachineLearningDiagnosticsConfig>,
    {
        self.desired_managed_machine_learning_diagnostics_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [desired_node_creation_config][crate::model::ClusterUpdate::desired_node_creation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeCreationConfig;
    /// let x = ClusterUpdate::new().set_desired_node_creation_config(NodeCreationConfig::default()/* use setters */);
    /// ```
    pub fn set_desired_node_creation_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeCreationConfig>,
    {
        self.desired_node_creation_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [desired_node_creation_config][crate::model::ClusterUpdate::desired_node_creation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpdate;
    /// use google_cloud_container_v1::model::NodeCreationConfig;
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_creation_config(Some(NodeCreationConfig::default()/* use setters */));
    /// let x = ClusterUpdate::new().set_or_clear_desired_node_creation_config(None::<NodeCreationConfig>);
    /// ```
    pub fn set_or_clear_desired_node_creation_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeCreationConfig>,
    {
        self.desired_node_creation_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ClusterUpdate {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ClusterUpdate"
    }
}

/// AdditionalPodRangesConfig is the configuration for additional pod secondary
/// ranges supporting the ClusterUpdate message.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdditionalPodRangesConfig {
    /// Name for pod secondary ipv4 range which has the actual range defined ahead.
    pub pod_range_names: std::vec::Vec<std::string::String>,

    /// Output only. Information for additional pod range.
    pub pod_range_info: std::vec::Vec<crate::model::RangeInfo>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdditionalPodRangesConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [pod_range_names][crate::model::AdditionalPodRangesConfig::pod_range_names].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// let x = AdditionalPodRangesConfig::new().set_pod_range_names(["a", "b", "c"]);
    /// ```
    pub fn set_pod_range_names<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.pod_range_names = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [pod_range_info][crate::model::AdditionalPodRangesConfig::pod_range_info].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalPodRangesConfig;
    /// use google_cloud_container_v1::model::RangeInfo;
    /// let x = AdditionalPodRangesConfig::new()
    ///     .set_pod_range_info([
    ///         RangeInfo::default()/* use setters */,
    ///         RangeInfo::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_pod_range_info<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::RangeInfo>,
    {
        use std::iter::Iterator;
        self.pod_range_info = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for AdditionalPodRangesConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdditionalPodRangesConfig"
    }
}

/// AdditionalIPRangesConfig is the configuration for individual additional
/// subnetwork attached to the cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdditionalIPRangesConfig {
    /// Name of the subnetwork. This can be the full path of the subnetwork or
    /// just the name.
    /// Example1: my-subnet
    /// Example2: projects/gke-project/regions/us-central1/subnetworks/my-subnet
    pub subnetwork: std::string::String,

    /// List of secondary ranges names within this subnetwork that can be used for
    /// pod IPs.
    /// Example1: gke-pod-range1
    /// Example2: gke-pod-range1,gke-pod-range2
    pub pod_ipv4_range_names: std::vec::Vec<std::string::String>,

    /// Draining status of the additional subnet.
    pub status: crate::model::additional_ip_ranges_config::Status,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdditionalIPRangesConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [subnetwork][crate::model::AdditionalIPRangesConfig::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalIPRangesConfig;
    /// let x = AdditionalIPRangesConfig::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [pod_ipv4_range_names][crate::model::AdditionalIPRangesConfig::pod_ipv4_range_names].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalIPRangesConfig;
    /// let x = AdditionalIPRangesConfig::new().set_pod_ipv4_range_names(["a", "b", "c"]);
    /// ```
    pub fn set_pod_ipv4_range_names<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.pod_ipv4_range_names = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [status][crate::model::AdditionalIPRangesConfig::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdditionalIPRangesConfig;
    /// use google_cloud_container_v1::model::additional_ip_ranges_config::Status;
    /// let x0 = AdditionalIPRangesConfig::new().set_status(Status::Active);
    /// let x1 = AdditionalIPRangesConfig::new().set_status(Status::Draining);
    /// ```
    pub fn set_status<T: std::convert::Into<crate::model::additional_ip_ranges_config::Status>>(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }
}

impl wkt::message::Message for AdditionalIPRangesConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdditionalIPRangesConfig"
    }
}

/// Defines additional types related to [AdditionalIPRangesConfig].
pub mod additional_ip_ranges_config {
    #[allow(unused_imports)]
    use super::*;

    /// Additional subnet with DRAINING status will not be selected during new node
    /// pool creation. To undrain the draining status, update the cluster to set
    /// the subnet to ACTIVE status. To remove the additional subnet, use the
    /// update cluster API to remove the subnet from the
    /// desired_additional_ip_ranges list. IP ranges can be removed regardless of
    /// its status, as long as no node pools are using them.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Status {
        /// Not set, same as ACTIVE.
        Unspecified,
        /// ACTIVE status indicates that the subnet is available for new node pool
        /// creation.
        Active,
        /// DRAINING status indicates that the subnet is not used for new node pool
        /// creation.
        Draining,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Status::value] or
        /// [Status::name].
        UnknownValue(status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Status {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Active => std::option::Option::Some(1),
                Self::Draining => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATUS_UNSPECIFIED"),
                Self::Active => std::option::Option::Some("ACTIVE"),
                Self::Draining => std::option::Option::Some("DRAINING"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Status {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Status {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Status {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Active,
                2 => Self::Draining,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Status {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATUS_UNSPECIFIED" => Self::Unspecified,
                "ACTIVE" => Self::Active,
                "DRAINING" => Self::Draining,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Status {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Active => serializer.serialize_i32(1),
                Self::Draining => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Status {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Status>::new(
                ".google.container.v1.AdditionalIPRangesConfig.Status",
            ))
        }
    }
}

/// DesiredAdditionalIPRangesConfig is a wrapper used for cluster update
/// operation and contains multiple AdditionalIPRangesConfigs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DesiredAdditionalIPRangesConfig {
    /// List of additional IP ranges configs where each AdditionalIPRangesConfig
    /// corresponds to one subnetwork's IP ranges
    pub additional_ip_ranges_configs: std::vec::Vec<crate::model::AdditionalIPRangesConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DesiredAdditionalIPRangesConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [additional_ip_ranges_configs][crate::model::DesiredAdditionalIPRangesConfig::additional_ip_ranges_configs].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DesiredAdditionalIPRangesConfig;
    /// use google_cloud_container_v1::model::AdditionalIPRangesConfig;
    /// let x = DesiredAdditionalIPRangesConfig::new()
    ///     .set_additional_ip_ranges_configs([
    ///         AdditionalIPRangesConfig::default()/* use setters */,
    ///         AdditionalIPRangesConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_additional_ip_ranges_configs<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AdditionalIPRangesConfig>,
    {
        use std::iter::Iterator;
        self.additional_ip_ranges_configs = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DesiredAdditionalIPRangesConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DesiredAdditionalIPRangesConfig"
    }
}

/// AutoIpamConfig contains all information related to Auto IPAM
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AutoIpamConfig {
    /// The flag that enables Auto IPAM on this cluster
    pub enabled: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AutoIpamConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::AutoIpamConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = AutoIpamConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enabled][crate::model::AutoIpamConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoIpamConfig;
    /// let x = AutoIpamConfig::new().set_or_clear_enabled(Some(false));
    /// let x = AutoIpamConfig::new().set_or_clear_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AutoIpamConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AutoIpamConfig"
    }
}

/// RangeInfo contains the range name and the range utilization by this cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RangeInfo {
    /// Output only. Name of a range.
    pub range_name: std::string::String,

    /// Output only. The utilization of the range.
    pub utilization: f64,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RangeInfo {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [range_name][crate::model::RangeInfo::range_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RangeInfo;
    /// let x = RangeInfo::new().set_range_name("example");
    /// ```
    pub fn set_range_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.range_name = v.into();
        self
    }

    /// Sets the value of [utilization][crate::model::RangeInfo::utilization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RangeInfo;
    /// let x = RangeInfo::new().set_utilization(42.0);
    /// ```
    pub fn set_utilization<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
        self.utilization = v.into();
        self
    }
}

impl wkt::message::Message for RangeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RangeInfo"
    }
}

/// DesiredEnterpriseConfig is a wrapper used for updating enterprise_config.
///
/// Deprecated: GKE Enterprise features are now available without an Enterprise
/// tier.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DesiredEnterpriseConfig {
    /// desired_tier specifies the desired tier of the cluster.
    pub desired_tier: crate::model::enterprise_config::ClusterTier,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DesiredEnterpriseConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [desired_tier][crate::model::DesiredEnterpriseConfig::desired_tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DesiredEnterpriseConfig;
    /// use google_cloud_container_v1::model::enterprise_config::ClusterTier;
    /// let x0 = DesiredEnterpriseConfig::new().set_desired_tier(ClusterTier::Standard);
    /// let x1 = DesiredEnterpriseConfig::new().set_desired_tier(ClusterTier::Enterprise);
    /// ```
    pub fn set_desired_tier<T: std::convert::Into<crate::model::enterprise_config::ClusterTier>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_tier = v.into();
        self
    }
}

impl wkt::message::Message for DesiredEnterpriseConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DesiredEnterpriseConfig"
    }
}

/// This operation resource represents operations that may have happened or are
/// happening on the cluster. All fields are output only.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Operation {
    /// Output only. The server-assigned ID for the operation.
    pub name: std::string::String,

    /// Output only. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the operation is taking place. This field is deprecated, use
    /// location instead.
    #[deprecated]
    pub zone: std::string::String,

    /// Output only. The operation type.
    pub operation_type: crate::model::operation::Type,

    /// Output only. The current status of the operation.
    pub status: crate::model::operation::Status,

    /// Output only. Detailed operation progress, if available.
    pub detail: std::string::String,

    /// Output only. If an error has occurred, a textual description of the error.
    /// Deprecated. Use the field error instead.
    #[deprecated]
    pub status_message: std::string::String,

    /// Output only. Server-defined URI for the operation. Example:
    /// `<https://container.googleapis.com/v1alpha1/projects/123/locations/us-central1/operations/operation-123>`.
    pub self_link: std::string::String,

    /// Output only. Server-defined URI for the target of the operation. The format
    /// of this is a URI to the resource being modified (such as a cluster, node
    /// pool, or node). For node pool repairs, there may be multiple nodes being
    /// repaired, but only one will be the target.
    ///
    /// Examples:
    ///
    ///
    /// ##
    ///
    /// `<https://container.googleapis.com/v1/projects/123/locations/us-central1/clusters/my-cluster>`
    ///
    /// ##
    ///
    /// `<https://container.googleapis.com/v1/projects/123/zones/us-central1-c/clusters/my-cluster/nodePools/my-np>`
    ///
    /// `<https://container.googleapis.com/v1/projects/123/zones/us-central1-c/clusters/my-cluster/nodePools/my-np/node/my-node>`
    pub target_link: std::string::String,

    /// Output only. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/regions-zones/regions-zones#available)
    /// or
    /// [region](https://cloud.google.com/compute/docs/regions-zones/regions-zones#available)
    /// in which the cluster resides.
    pub location: std::string::String,

    /// Output only. The time the operation started, in
    /// [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
    pub start_time: std::string::String,

    /// Output only. The time the operation completed, in
    /// [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
    pub end_time: std::string::String,

    /// Output only. Progress information for an operation.
    pub progress: std::option::Option<crate::model::OperationProgress>,

    /// Which conditions caused the current cluster state.
    /// Deprecated. Use field error instead.
    #[deprecated]
    pub cluster_conditions: std::vec::Vec<crate::model::StatusCondition>,

    /// Which conditions caused the current node pool state.
    /// Deprecated. Use field error instead.
    #[deprecated]
    pub nodepool_conditions: std::vec::Vec<crate::model::StatusCondition>,

    /// The error result of the operation in case of failure.
    pub error: std::option::Option<google_cloud_rpc::model::Status>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Operation {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::Operation::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::Operation::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [operation_type][crate::model::Operation::operation_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::operation::Type;
    /// let x0 = Operation::new().set_operation_type(Type::CreateCluster);
    /// let x1 = Operation::new().set_operation_type(Type::DeleteCluster);
    /// let x2 = Operation::new().set_operation_type(Type::UpgradeMaster);
    /// ```
    pub fn set_operation_type<T: std::convert::Into<crate::model::operation::Type>>(
        mut self,
        v: T,
    ) -> Self {
        self.operation_type = v.into();
        self
    }

    /// Sets the value of [status][crate::model::Operation::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::operation::Status;
    /// let x0 = Operation::new().set_status(Status::Pending);
    /// let x1 = Operation::new().set_status(Status::Running);
    /// let x2 = Operation::new().set_status(Status::Done);
    /// ```
    pub fn set_status<T: std::convert::Into<crate::model::operation::Status>>(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }

    /// Sets the value of [detail][crate::model::Operation::detail].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_detail("example");
    /// ```
    pub fn set_detail<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.detail = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::Operation::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_status_message("example");
    /// ```
    #[deprecated]
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [self_link][crate::model::Operation::self_link].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_self_link("example");
    /// ```
    pub fn set_self_link<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.self_link = v.into();
        self
    }

    /// Sets the value of [target_link][crate::model::Operation::target_link].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_target_link("example");
    /// ```
    pub fn set_target_link<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_link = v.into();
        self
    }

    /// Sets the value of [location][crate::model::Operation::location].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_location("example");
    /// ```
    pub fn set_location<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.location = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::Operation::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_start_time("example");
    /// ```
    pub fn set_start_time<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [end_time][crate::model::Operation::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// let x = Operation::new().set_end_time("example");
    /// ```
    pub fn set_end_time<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.end_time = v.into();
        self
    }

    /// Sets the value of [progress][crate::model::Operation::progress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::OperationProgress;
    /// let x = Operation::new().set_progress(OperationProgress::default()/* use setters */);
    /// ```
    pub fn set_progress<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::OperationProgress>,
    {
        self.progress = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [progress][crate::model::Operation::progress].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::OperationProgress;
    /// let x = Operation::new().set_or_clear_progress(Some(OperationProgress::default()/* use setters */));
    /// let x = Operation::new().set_or_clear_progress(None::<OperationProgress>);
    /// ```
    pub fn set_or_clear_progress<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::OperationProgress>,
    {
        self.progress = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cluster_conditions][crate::model::Operation::cluster_conditions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::StatusCondition;
    /// let x = Operation::new()
    ///     .set_cluster_conditions([
    ///         StatusCondition::default()/* use setters */,
    ///         StatusCondition::default()/* use (different) setters */,
    ///     ]);
    /// ```
    #[deprecated]
    pub fn set_cluster_conditions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::StatusCondition>,
    {
        use std::iter::Iterator;
        self.cluster_conditions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [nodepool_conditions][crate::model::Operation::nodepool_conditions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_container_v1::model::StatusCondition;
    /// let x = Operation::new()
    ///     .set_nodepool_conditions([
    ///         StatusCondition::default()/* use setters */,
    ///         StatusCondition::default()/* use (different) setters */,
    ///     ]);
    /// ```
    #[deprecated]
    pub fn set_nodepool_conditions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::StatusCondition>,
    {
        use std::iter::Iterator;
        self.nodepool_conditions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [error][crate::model::Operation::error].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_rpc::model::Status;
    /// let x = Operation::new().set_error(Status::default()/* use setters */);
    /// ```
    pub fn set_error<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.error = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [error][crate::model::Operation::error].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Operation;
    /// use google_cloud_rpc::model::Status;
    /// let x = Operation::new().set_or_clear_error(Some(Status::default()/* use setters */));
    /// let x = Operation::new().set_or_clear_error(None::<Status>);
    /// ```
    pub fn set_or_clear_error<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_rpc::model::Status>,
    {
        self.error = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Operation {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.Operation"
    }
}

/// Defines additional types related to [Operation].
pub mod operation {
    #[allow(unused_imports)]
    use super::*;

    /// Current status of the operation.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Status {
        /// Not set.
        Unspecified,
        /// The operation has been created.
        Pending,
        /// The operation is currently running.
        Running,
        /// The operation is done, either cancelled or completed.
        Done,
        /// The operation is aborting.
        Aborting,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Status::value] or
        /// [Status::name].
        UnknownValue(status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Status {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Pending => std::option::Option::Some(1),
                Self::Running => std::option::Option::Some(2),
                Self::Done => std::option::Option::Some(3),
                Self::Aborting => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATUS_UNSPECIFIED"),
                Self::Pending => std::option::Option::Some("PENDING"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::Done => std::option::Option::Some("DONE"),
                Self::Aborting => std::option::Option::Some("ABORTING"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Status {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Status {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Status {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Pending,
                2 => Self::Running,
                3 => Self::Done,
                4 => Self::Aborting,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Status {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATUS_UNSPECIFIED" => Self::Unspecified,
                "PENDING" => Self::Pending,
                "RUNNING" => Self::Running,
                "DONE" => Self::Done,
                "ABORTING" => Self::Aborting,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Status {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Pending => serializer.serialize_i32(1),
                Self::Running => serializer.serialize_i32(2),
                Self::Done => serializer.serialize_i32(3),
                Self::Aborting => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Status {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Status>::new(
                ".google.container.v1.Operation.Status",
            ))
        }
    }

    /// Operation type categorizes the operation.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Not set.
        Unspecified,
        /// The cluster is being created. The cluster should be assumed to be
        /// unusable until the operation finishes.
        ///
        /// In the event of the operation failing, the cluster will enter the
        /// [ERROR state][google.container.v1.Cluster.Status.ERROR] and eventually be
        /// deleted.
        ///
        /// [google.container.v1.Cluster.Status.ERROR]: crate::model::cluster::Status::Error
        CreateCluster,
        /// The cluster is being deleted. The cluster should be assumed to be
        /// unusable as soon as this operation starts.
        ///
        /// In the event of the operation failing, the cluster will enter the
        /// [ERROR state][google.container.v1.Cluster.Status.ERROR] and the deletion
        /// will be automatically retried until completed.
        ///
        /// [google.container.v1.Cluster.Status.ERROR]: crate::model::cluster::Status::Error
        DeleteCluster,
        /// The [cluster
        /// version][google.container.v1.ClusterUpdate.desired_master_version] is
        /// being updated. Note that this includes "upgrades" to the same version,
        /// which are simply a recreation. This also includes
        /// [auto-upgrades](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-upgrades#upgrading_automatically).
        /// For more details, see [documentation on cluster
        /// upgrades](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-upgrades#cluster_upgrades).
        ///
        /// [google.container.v1.ClusterUpdate.desired_master_version]: crate::model::ClusterUpdate::desired_master_version
        UpgradeMaster,
        /// A node pool is being updated. Despite calling this an "upgrade", this
        /// includes most forms of updates to node pools. This also includes
        /// [auto-upgrades](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-upgrades).
        ///
        /// This operation sets the
        /// [progress][google.container.v1.Operation.progress] field and may be
        /// [canceled][google.container.v1.ClusterManager.CancelOperation].
        ///
        /// The upgrade strategy depends on [node pool
        /// configuration](https://cloud.google.com/kubernetes-engine/docs/concepts/node-pool-upgrade-strategies).
        /// The nodes are generally still usable during this operation.
        ///
        /// [google.container.v1.ClusterManager.CancelOperation]: crate::client::ClusterManager::cancel_operation
        /// [google.container.v1.Operation.progress]: crate::model::Operation::progress
        UpgradeNodes,
        /// A problem has been detected with the control plane and is being repaired.
        /// This operation type is initiated by GKE. For more details, see
        /// [documentation on
        /// repairs](https://cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions#repairs).
        RepairCluster,
        /// The cluster is being updated. This is a broad category of operations and
        /// includes operations that only change metadata as well as those that must
        /// recreate the entire cluster. If the control plane must be recreated, this
        /// will cause temporary downtime for zonal clusters.
        ///
        /// Some features require recreating the nodes as well. Those will be
        /// recreated as separate operations and the update may not be completely
        /// functional until the node pools recreations finish. Node recreations will
        /// generally follow [maintenance
        /// policies](https://cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions).
        ///
        /// Some GKE-initiated operations use this type. This includes certain types
        /// of auto-upgrades and incident mitigations.
        UpdateCluster,
        /// A node pool is being created. The node pool should be assumed to be
        /// unusable until this operation finishes. In the event of an error, the
        /// node pool may be partially created.
        ///
        /// If enabled, [node
        /// autoprovisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
        /// may have automatically initiated such operations.
        CreateNodePool,
        /// The node pool is being deleted. The node pool should be assumed to be
        /// unusable as soon as this operation starts.
        DeleteNodePool,
        /// The node pool's [manamagent][google.container.v1.NodePool.management]
        /// field is being updated. These operations only update metadata and may be
        /// concurrent with most other operations.
        ///
        /// [google.container.v1.NodePool.management]: crate::model::NodePool::management
        SetNodePoolManagement,
        /// A problem has been detected with nodes and [they are being
        /// repaired](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-repair).
        /// This operation type is initiated by GKE, typically automatically. This
        /// operation may be concurrent with other operations and there may be
        /// multiple repairs occurring on the same node pool.
        AutoRepairNodes,
        /// Unused. Automatic node upgrade uses
        /// [UPGRADE_NODES][google.container.v1.Operation.Type.UPGRADE_NODES].
        ///
        /// [google.container.v1.Operation.Type.UPGRADE_NODES]: crate::model::operation::Type::UpgradeNodes
        #[deprecated]
        AutoUpgradeNodes,
        /// Unused. Updating labels uses
        /// [UPDATE_CLUSTER][google.container.v1.Operation.Type.UPDATE_CLUSTER].
        ///
        /// [google.container.v1.Operation.Type.UPDATE_CLUSTER]: crate::model::operation::Type::UpdateCluster
        #[deprecated]
        SetLabels,
        /// Unused. Updating master auth uses
        /// [UPDATE_CLUSTER][google.container.v1.Operation.Type.UPDATE_CLUSTER].
        ///
        /// [google.container.v1.Operation.Type.UPDATE_CLUSTER]: crate::model::operation::Type::UpdateCluster
        #[deprecated]
        SetMasterAuth,
        /// The node pool is being resized. With the exception of resizing to or from
        /// size zero, the node pool is generally usable during this operation.
        SetNodePoolSize,
        /// Unused. Updating network policy uses
        /// [UPDATE_CLUSTER][google.container.v1.Operation.Type.UPDATE_CLUSTER].
        ///
        /// [google.container.v1.Operation.Type.UPDATE_CLUSTER]: crate::model::operation::Type::UpdateCluster
        #[deprecated]
        SetNetworkPolicy,
        /// Unused. Updating maintenance policy uses
        /// [UPDATE_CLUSTER][google.container.v1.Operation.Type.UPDATE_CLUSTER].
        ///
        /// [google.container.v1.Operation.Type.UPDATE_CLUSTER]: crate::model::operation::Type::UpdateCluster
        #[deprecated]
        SetMaintenancePolicy,
        /// The control plane is being resized. This operation type is initiated by
        /// GKE. These operations are often performed preemptively to ensure that the
        /// control plane has sufficient resources and is not typically an indication
        /// of issues. For more details, see
        /// [documentation on
        /// resizes](https://cloud.google.com/kubernetes-engine/docs/concepts/maintenance-windows-and-exclusions#repairs).
        ResizeCluster,
        /// Fleet features of GKE Enterprise are being upgraded. The cluster should
        /// be assumed to be blocked for other upgrades until the operation finishes.
        FleetFeatureUpgrade,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Type::value] or
        /// [Type::name].
        UnknownValue(r#type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod r#type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Type {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::CreateCluster => std::option::Option::Some(1),
                Self::DeleteCluster => std::option::Option::Some(2),
                Self::UpgradeMaster => std::option::Option::Some(3),
                Self::UpgradeNodes => std::option::Option::Some(4),
                Self::RepairCluster => std::option::Option::Some(5),
                Self::UpdateCluster => std::option::Option::Some(6),
                Self::CreateNodePool => std::option::Option::Some(7),
                Self::DeleteNodePool => std::option::Option::Some(8),
                Self::SetNodePoolManagement => std::option::Option::Some(9),
                Self::AutoRepairNodes => std::option::Option::Some(10),
                Self::AutoUpgradeNodes => std::option::Option::Some(11),
                Self::SetLabels => std::option::Option::Some(12),
                Self::SetMasterAuth => std::option::Option::Some(13),
                Self::SetNodePoolSize => std::option::Option::Some(14),
                Self::SetNetworkPolicy => std::option::Option::Some(15),
                Self::SetMaintenancePolicy => std::option::Option::Some(16),
                Self::ResizeCluster => std::option::Option::Some(18),
                Self::FleetFeatureUpgrade => std::option::Option::Some(19),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("TYPE_UNSPECIFIED"),
                Self::CreateCluster => std::option::Option::Some("CREATE_CLUSTER"),
                Self::DeleteCluster => std::option::Option::Some("DELETE_CLUSTER"),
                Self::UpgradeMaster => std::option::Option::Some("UPGRADE_MASTER"),
                Self::UpgradeNodes => std::option::Option::Some("UPGRADE_NODES"),
                Self::RepairCluster => std::option::Option::Some("REPAIR_CLUSTER"),
                Self::UpdateCluster => std::option::Option::Some("UPDATE_CLUSTER"),
                Self::CreateNodePool => std::option::Option::Some("CREATE_NODE_POOL"),
                Self::DeleteNodePool => std::option::Option::Some("DELETE_NODE_POOL"),
                Self::SetNodePoolManagement => {
                    std::option::Option::Some("SET_NODE_POOL_MANAGEMENT")
                }
                Self::AutoRepairNodes => std::option::Option::Some("AUTO_REPAIR_NODES"),
                Self::AutoUpgradeNodes => std::option::Option::Some("AUTO_UPGRADE_NODES"),
                Self::SetLabels => std::option::Option::Some("SET_LABELS"),
                Self::SetMasterAuth => std::option::Option::Some("SET_MASTER_AUTH"),
                Self::SetNodePoolSize => std::option::Option::Some("SET_NODE_POOL_SIZE"),
                Self::SetNetworkPolicy => std::option::Option::Some("SET_NETWORK_POLICY"),
                Self::SetMaintenancePolicy => std::option::Option::Some("SET_MAINTENANCE_POLICY"),
                Self::ResizeCluster => std::option::Option::Some("RESIZE_CLUSTER"),
                Self::FleetFeatureUpgrade => std::option::Option::Some("FLEET_FEATURE_UPGRADE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Type {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Type {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Type {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::CreateCluster,
                2 => Self::DeleteCluster,
                3 => Self::UpgradeMaster,
                4 => Self::UpgradeNodes,
                5 => Self::RepairCluster,
                6 => Self::UpdateCluster,
                7 => Self::CreateNodePool,
                8 => Self::DeleteNodePool,
                9 => Self::SetNodePoolManagement,
                10 => Self::AutoRepairNodes,
                11 => Self::AutoUpgradeNodes,
                12 => Self::SetLabels,
                13 => Self::SetMasterAuth,
                14 => Self::SetNodePoolSize,
                15 => Self::SetNetworkPolicy,
                16 => Self::SetMaintenancePolicy,
                18 => Self::ResizeCluster,
                19 => Self::FleetFeatureUpgrade,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Type {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TYPE_UNSPECIFIED" => Self::Unspecified,
                "CREATE_CLUSTER" => Self::CreateCluster,
                "DELETE_CLUSTER" => Self::DeleteCluster,
                "UPGRADE_MASTER" => Self::UpgradeMaster,
                "UPGRADE_NODES" => Self::UpgradeNodes,
                "REPAIR_CLUSTER" => Self::RepairCluster,
                "UPDATE_CLUSTER" => Self::UpdateCluster,
                "CREATE_NODE_POOL" => Self::CreateNodePool,
                "DELETE_NODE_POOL" => Self::DeleteNodePool,
                "SET_NODE_POOL_MANAGEMENT" => Self::SetNodePoolManagement,
                "AUTO_REPAIR_NODES" => Self::AutoRepairNodes,
                "AUTO_UPGRADE_NODES" => Self::AutoUpgradeNodes,
                "SET_LABELS" => Self::SetLabels,
                "SET_MASTER_AUTH" => Self::SetMasterAuth,
                "SET_NODE_POOL_SIZE" => Self::SetNodePoolSize,
                "SET_NETWORK_POLICY" => Self::SetNetworkPolicy,
                "SET_MAINTENANCE_POLICY" => Self::SetMaintenancePolicy,
                "RESIZE_CLUSTER" => Self::ResizeCluster,
                "FLEET_FEATURE_UPGRADE" => Self::FleetFeatureUpgrade,
                _ => Self::UnknownValue(r#type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Type {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::CreateCluster => serializer.serialize_i32(1),
                Self::DeleteCluster => serializer.serialize_i32(2),
                Self::UpgradeMaster => serializer.serialize_i32(3),
                Self::UpgradeNodes => serializer.serialize_i32(4),
                Self::RepairCluster => serializer.serialize_i32(5),
                Self::UpdateCluster => serializer.serialize_i32(6),
                Self::CreateNodePool => serializer.serialize_i32(7),
                Self::DeleteNodePool => serializer.serialize_i32(8),
                Self::SetNodePoolManagement => serializer.serialize_i32(9),
                Self::AutoRepairNodes => serializer.serialize_i32(10),
                Self::AutoUpgradeNodes => serializer.serialize_i32(11),
                Self::SetLabels => serializer.serialize_i32(12),
                Self::SetMasterAuth => serializer.serialize_i32(13),
                Self::SetNodePoolSize => serializer.serialize_i32(14),
                Self::SetNetworkPolicy => serializer.serialize_i32(15),
                Self::SetMaintenancePolicy => serializer.serialize_i32(16),
                Self::ResizeCluster => serializer.serialize_i32(18),
                Self::FleetFeatureUpgrade => serializer.serialize_i32(19),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Type {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                ".google.container.v1.Operation.Type",
            ))
        }
    }
}

/// Information about operation (or operation stage) progress.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationProgress {
    /// A non-parameterized string describing an operation stage.
    /// Unset for single-stage operations.
    pub name: std::string::String,

    /// Status of an operation stage.
    /// Unset for single-stage operations.
    pub status: crate::model::operation::Status,

    /// Progress metric bundle, for example:
    /// metrics: [{name: "nodes done",     int_value: 15},
    /// {name: "nodes total",    int_value: 32}]
    /// or
    /// metrics: [{name: "progress",       double_value: 0.56},
    /// {name: "progress scale", double_value: 1.0}]
    pub metrics: std::vec::Vec<crate::model::operation_progress::Metric>,

    /// Substages of an operation or a stage.
    pub stages: std::vec::Vec<crate::model::OperationProgress>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OperationProgress {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::OperationProgress::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::OperationProgress;
    /// let x = OperationProgress::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [status][crate::model::OperationProgress::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::OperationProgress;
    /// use google_cloud_container_v1::model::operation::Status;
    /// let x0 = OperationProgress::new().set_status(Status::Pending);
    /// let x1 = OperationProgress::new().set_status(Status::Running);
    /// let x2 = OperationProgress::new().set_status(Status::Done);
    /// ```
    pub fn set_status<T: std::convert::Into<crate::model::operation::Status>>(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }

    /// Sets the value of [metrics][crate::model::OperationProgress::metrics].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::OperationProgress;
    /// use google_cloud_container_v1::model::operation_progress::Metric;
    /// let x = OperationProgress::new()
    ///     .set_metrics([
    ///         Metric::default()/* use setters */,
    ///         Metric::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_metrics<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::operation_progress::Metric>,
    {
        use std::iter::Iterator;
        self.metrics = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [stages][crate::model::OperationProgress::stages].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::OperationProgress;
    /// let x = OperationProgress::new()
    ///     .set_stages([
    ///         OperationProgress::default()/* use setters */,
    ///         OperationProgress::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_stages<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::OperationProgress>,
    {
        use std::iter::Iterator;
        self.stages = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for OperationProgress {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.OperationProgress"
    }
}

/// Defines additional types related to [OperationProgress].
pub mod operation_progress {
    #[allow(unused_imports)]
    use super::*;

    /// Progress metric is (string, int|float|string) pair.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Metric {
        /// Required. Metric name, e.g., "nodes total", "percent done".
        pub name: std::string::String,

        /// Strictly one of the values is required.
        pub value: std::option::Option<crate::model::operation_progress::metric::Value>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl Metric {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [name][crate::model::operation_progress::Metric::name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::operation_progress::Metric;
        /// let x = Metric::new().set_name("example");
        /// ```
        pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.name = v.into();
            self
        }

        /// Sets the value of [value][crate::model::operation_progress::Metric::value].
        ///
        /// Note that all the setters affecting `value` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::operation_progress::Metric;
        /// use google_cloud_container_v1::model::operation_progress::metric::Value;
        /// let x = Metric::new().set_value(Some(Value::IntValue(42)));
        /// ```
        pub fn set_value<
            T: std::convert::Into<
                    std::option::Option<crate::model::operation_progress::metric::Value>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.value = v.into();
            self
        }

        /// The value of [value][crate::model::operation_progress::Metric::value]
        /// if it holds a `IntValue`, `None` if the field is not set or
        /// holds a different branch.
        pub fn int_value(&self) -> std::option::Option<&i64> {
            #[allow(unreachable_patterns)]
            self.value.as_ref().and_then(|v| match v {
                crate::model::operation_progress::metric::Value::IntValue(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [value][crate::model::operation_progress::Metric::value]
        /// to hold a `IntValue`.
        ///
        /// Note that all the setters affecting `value` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::operation_progress::Metric;
        /// let x = Metric::new().set_int_value(42);
        /// assert!(x.int_value().is_some());
        /// assert!(x.double_value().is_none());
        /// assert!(x.string_value().is_none());
        /// ```
        pub fn set_int_value<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
            self.value = std::option::Option::Some(
                crate::model::operation_progress::metric::Value::IntValue(v.into()),
            );
            self
        }

        /// The value of [value][crate::model::operation_progress::Metric::value]
        /// if it holds a `DoubleValue`, `None` if the field is not set or
        /// holds a different branch.
        pub fn double_value(&self) -> std::option::Option<&f64> {
            #[allow(unreachable_patterns)]
            self.value.as_ref().and_then(|v| match v {
                crate::model::operation_progress::metric::Value::DoubleValue(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [value][crate::model::operation_progress::Metric::value]
        /// to hold a `DoubleValue`.
        ///
        /// Note that all the setters affecting `value` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::operation_progress::Metric;
        /// let x = Metric::new().set_double_value(42.0);
        /// assert!(x.double_value().is_some());
        /// assert!(x.int_value().is_none());
        /// assert!(x.string_value().is_none());
        /// ```
        pub fn set_double_value<T: std::convert::Into<f64>>(mut self, v: T) -> Self {
            self.value = std::option::Option::Some(
                crate::model::operation_progress::metric::Value::DoubleValue(v.into()),
            );
            self
        }

        /// The value of [value][crate::model::operation_progress::Metric::value]
        /// if it holds a `StringValue`, `None` if the field is not set or
        /// holds a different branch.
        pub fn string_value(&self) -> std::option::Option<&std::string::String> {
            #[allow(unreachable_patterns)]
            self.value.as_ref().and_then(|v| match v {
                crate::model::operation_progress::metric::Value::StringValue(v) => {
                    std::option::Option::Some(v)
                }
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [value][crate::model::operation_progress::Metric::value]
        /// to hold a `StringValue`.
        ///
        /// Note that all the setters affecting `value` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::operation_progress::Metric;
        /// let x = Metric::new().set_string_value("example");
        /// assert!(x.string_value().is_some());
        /// assert!(x.int_value().is_none());
        /// assert!(x.double_value().is_none());
        /// ```
        pub fn set_string_value<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.value = std::option::Option::Some(
                crate::model::operation_progress::metric::Value::StringValue(v.into()),
            );
            self
        }
    }

    impl wkt::message::Message for Metric {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.OperationProgress.Metric"
        }
    }

    /// Defines additional types related to [Metric].
    pub mod metric {
        #[allow(unused_imports)]
        use super::*;

        /// Strictly one of the values is required.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Value {
            /// For metrics with integer value.
            IntValue(i64),
            /// For metrics with floating point value.
            DoubleValue(f64),
            /// For metrics with custom values (ratios, visual progress, etc.).
            StringValue(std::string::String),
        }
    }
}

/// CreateClusterRequest creates a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateClusterRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the parent field.
    #[deprecated]
    pub zone: std::string::String,

    /// Required. A [cluster
    /// resource](https://cloud.google.com/container-engine/reference/rest/v1/projects.locations.clusters)
    pub cluster: std::option::Option<crate::model::Cluster>,

    /// The parent (project and location) where the cluster will be created.
    /// Specified in the format `projects/*/locations/*`.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateClusterRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::CreateClusterRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateClusterRequest;
    /// let x = CreateClusterRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::CreateClusterRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateClusterRequest;
    /// let x = CreateClusterRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster][crate::model::CreateClusterRequest::cluster].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateClusterRequest;
    /// use google_cloud_container_v1::model::Cluster;
    /// let x = CreateClusterRequest::new().set_cluster(Cluster::default()/* use setters */);
    /// ```
    pub fn set_cluster<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::Cluster>,
    {
        self.cluster = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cluster][crate::model::CreateClusterRequest::cluster].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateClusterRequest;
    /// use google_cloud_container_v1::model::Cluster;
    /// let x = CreateClusterRequest::new().set_or_clear_cluster(Some(Cluster::default()/* use setters */));
    /// let x = CreateClusterRequest::new().set_or_clear_cluster(None::<Cluster>);
    /// ```
    pub fn set_or_clear_cluster<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::Cluster>,
    {
        self.cluster = v.map(|x| x.into());
        self
    }

    /// Sets the value of [parent][crate::model::CreateClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateClusterRequest;
    /// let x = CreateClusterRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for CreateClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CreateClusterRequest"
    }
}

/// GetClusterRequest gets the settings of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetClusterRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to retrieve.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// The name (project, location, cluster) of the cluster to retrieve.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetClusterRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::GetClusterRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetClusterRequest;
    /// let x = GetClusterRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::GetClusterRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetClusterRequest;
    /// let x = GetClusterRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::GetClusterRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetClusterRequest;
    /// let x = GetClusterRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::GetClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetClusterRequest;
    /// let x = GetClusterRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetClusterRequest"
    }
}

/// UpdateClusterRequest updates the settings of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateClusterRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. A description of the update.
    pub update: std::option::Option<crate::model::ClusterUpdate>,

    /// The name (project, location, cluster) of the cluster to update.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateClusterRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::UpdateClusterRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// let x = UpdateClusterRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::UpdateClusterRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// let x = UpdateClusterRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::UpdateClusterRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// let x = UpdateClusterRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [update][crate::model::UpdateClusterRequest::update].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = UpdateClusterRequest::new().set_update(ClusterUpdate::default()/* use setters */);
    /// ```
    pub fn set_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClusterUpdate>,
    {
        self.update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update][crate::model::UpdateClusterRequest::update].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// use google_cloud_container_v1::model::ClusterUpdate;
    /// let x = UpdateClusterRequest::new().set_or_clear_update(Some(ClusterUpdate::default()/* use setters */));
    /// let x = UpdateClusterRequest::new().set_or_clear_update(None::<ClusterUpdate>);
    /// ```
    pub fn set_or_clear_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ClusterUpdate>,
    {
        self.update = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::UpdateClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateClusterRequest;
    /// let x = UpdateClusterRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for UpdateClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpdateClusterRequest"
    }
}

/// UpdateNodePoolRequests update a node pool's image and/or version.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateNodePoolRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// Required. The Kubernetes version to change the nodes to (typically an
    /// upgrade).
    ///
    /// Users may specify either explicit versions offered by Kubernetes Engine or
    /// version aliases, which have the following behavior:
    ///
    /// - "latest": picks the highest valid Kubernetes version
    /// - "1.X": picks the highest valid patch+gke.N patch in the 1.X version
    /// - "1.X.Y": picks the highest valid gke.N patch in the 1.X.Y version
    /// - "1.X.Y-gke.N": picks an explicit Kubernetes version
    /// - "-": picks the Kubernetes master version
    pub node_version: std::string::String,

    /// Required. The desired image type for the node pool. Please see
    /// <https://cloud.google.com/kubernetes-engine/docs/concepts/node-images>
    /// for available image types.
    pub image_type: std::string::String,

    /// The name (project, location, cluster, node pool) of the node pool to
    /// update. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    /// The desired name of the image name to use for this node.
    /// This is used to create clusters using a custom image.
    pub image: std::string::String,

    /// The project containing the desired image to use for this node pool.
    /// This is used to create clusters using a custom image.
    pub image_project: std::string::String,

    /// The desired list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the node pool's nodes should be located. Changing the locations
    /// for a node pool will result in nodes being either created or removed from
    /// the node pool, depending on whether locations are being added or removed.
    ///
    /// Warning: It is recommended to update node pool locations in a standalone
    /// API call. Do not combine a location update with changes to other fields
    /// (such as `tags`, `labels`, `taints`, etc.) in the same request.
    /// Otherwise, the API performs a structural modification where changes to
    /// other fields will only apply to newly created nodes and will not be
    /// applied to existing nodes in the node pool. To ensure all nodes are updated
    /// consistently, use a separate API call for location changes.
    pub locations: std::vec::Vec<std::string::String>,

    /// The desired workload metadata config for the node pool.
    pub workload_metadata_config: std::option::Option<crate::model::WorkloadMetadataConfig>,

    /// Upgrade settings control disruption and speed of the upgrade.
    pub upgrade_settings: std::option::Option<crate::model::node_pool::UpgradeSettings>,

    /// The desired network tags to be applied to all nodes in the node pool.
    /// If this field is not present, the tags will not be changed. Otherwise,
    /// the existing network tags will be *replaced* with the provided tags.
    pub tags: std::option::Option<crate::model::NetworkTags>,

    /// The desired node taints to be applied to all nodes in the node pool.
    /// If this field is not present, the taints will not be changed. Otherwise,
    /// the existing node taints will be *replaced* with the provided taints.
    pub taints: std::option::Option<crate::model::NodeTaints>,

    /// The desired node labels to be applied to all nodes in the node pool.
    /// If this field is not present, the labels will not be changed. Otherwise,
    /// the existing node labels will be *replaced* with the provided labels.
    pub labels: std::option::Option<crate::model::NodeLabels>,

    /// Parameters that can be configured on Linux nodes.
    pub linux_node_config: std::option::Option<crate::model::LinuxNodeConfig>,

    /// Node kubelet configs.
    pub kubelet_config: std::option::Option<crate::model::NodeKubeletConfig>,

    /// Node network config.
    pub node_network_config: std::option::Option<crate::model::NodeNetworkConfig>,

    /// GCFS config.
    pub gcfs_config: std::option::Option<crate::model::GcfsConfig>,

    /// Confidential nodes config.
    /// All the nodes in the node pool will be Confidential VM once enabled.
    pub confidential_nodes: std::option::Option<crate::model::ConfidentialNodes>,

    /// Enable or disable gvnic on the node pool.
    pub gvnic: std::option::Option<crate::model::VirtualNIC>,

    /// The current etag of the node pool.
    /// If an etag is provided and does not match the current etag of the node
    /// pool, update will be blocked and an ABORTED error will be returned.
    pub etag: std::string::String,

    /// Enable or disable NCCL fast socket for the node pool.
    pub fast_socket: std::option::Option<crate::model::FastSocket>,

    /// Logging configuration.
    pub logging_config: std::option::Option<crate::model::NodePoolLoggingConfig>,

    /// The resource labels for the node pool to use to annotate any related
    /// Google Compute Engine resources.
    pub resource_labels: std::option::Option<crate::model::ResourceLabels>,

    /// Parameters that can be configured on Windows nodes.
    pub windows_node_config: std::option::Option<crate::model::WindowsNodeConfig>,

    /// A list of hardware accelerators to be attached to each node.
    /// See
    /// <https://cloud.google.com/compute/docs/gpus>
    /// for more information about support for GPUs.
    pub accelerators: std::vec::Vec<crate::model::AcceleratorConfig>,

    /// Optional. The desired [Google Compute Engine machine
    /// type](https://cloud.google.com/compute/docs/machine-types)
    /// for nodes in the node pool. Initiates an upgrade operation that migrates
    /// the nodes in the node pool to the specified machine type.
    pub machine_type: std::string::String,

    /// Optional. The desired disk type (e.g. 'pd-standard', 'pd-ssd' or
    /// 'pd-balanced') for nodes in the node pool.
    /// Initiates an upgrade operation that migrates the nodes in the
    /// node pool to the specified disk type.
    pub disk_type: std::string::String,

    /// Optional. The desired disk size for nodes in the node pool specified in GB.
    /// The smallest allowed disk size is 10GB.
    /// Initiates an upgrade operation that migrates the nodes in the
    /// node pool to the specified disk size.
    pub disk_size_gb: i64,

    /// Desired resource manager tag keys and values to be attached to the nodes
    /// for managing Compute Engine firewalls using Network Firewall Policies.
    /// Existing tags will be replaced with new values.
    pub resource_manager_tags: std::option::Option<crate::model::ResourceManagerTags>,

    /// The desired containerd config for nodes in the node pool.
    /// Initiates an upgrade operation that recreates the nodes with the new
    /// config.
    pub containerd_config: std::option::Option<crate::model::ContainerdConfig>,

    /// Specifies the configuration of queued provisioning.
    pub queued_provisioning: std::option::Option<crate::model::node_pool::QueuedProvisioning>,

    /// List of Storage Pools where boot disks are provisioned.
    /// Existing Storage Pools will be replaced with storage-pools.
    pub storage_pools: std::vec::Vec<std::string::String>,

    /// The maximum duration for the nodes to exist.
    /// If unspecified, the nodes can exist indefinitely.
    pub max_run_duration: std::option::Option<wkt::Duration>,

    /// Flex Start flag for enabling Flex Start VM.
    pub flex_start: std::option::Option<bool>,

    /// The desired boot disk config for nodes in the node pool.
    /// Initiates an upgrade operation that migrates the nodes in the
    /// node pool to the specified boot disk config.
    pub boot_disk: std::option::Option<crate::model::BootDisk>,

    /// The desired node drain configuration for nodes in the node pool.
    pub node_drain_config: std::option::Option<crate::model::node_pool::NodeDrainConfig>,

    /// Consolidation delay defines duration after which the Cluster Autoscaler can
    /// scale down underutilized nodes. If not set, nodes are scaled down by
    /// default behavior, i.e. according to the chosen autoscaling profile.
    pub consolidation_delay: std::option::Option<wkt::Duration>,

    /// The taint configuration for the node pool.
    pub taint_config: std::option::Option<crate::model::TaintConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateNodePoolRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::UpdateNodePoolRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::UpdateNodePoolRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::UpdateNodePoolRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::UpdateNodePoolRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [node_version][crate::model::UpdateNodePoolRequest::node_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_node_version("example");
    /// ```
    pub fn set_node_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_version = v.into();
        self
    }

    /// Sets the value of [image_type][crate::model::UpdateNodePoolRequest::image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_image_type("example");
    /// ```
    pub fn set_image_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_type = v.into();
        self
    }

    /// Sets the value of [name][crate::model::UpdateNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [image][crate::model::UpdateNodePoolRequest::image].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_image("example");
    /// ```
    pub fn set_image<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image = v.into();
        self
    }

    /// Sets the value of [image_project][crate::model::UpdateNodePoolRequest::image_project].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_image_project("example");
    /// ```
    pub fn set_image_project<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_project = v.into();
        self
    }

    /// Sets the value of [locations][crate::model::UpdateNodePoolRequest::locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_locations(["a", "b", "c"]);
    /// ```
    pub fn set_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [workload_metadata_config][crate::model::UpdateNodePoolRequest::workload_metadata_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::WorkloadMetadataConfig;
    /// let x = UpdateNodePoolRequest::new().set_workload_metadata_config(WorkloadMetadataConfig::default()/* use setters */);
    /// ```
    pub fn set_workload_metadata_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadMetadataConfig>,
    {
        self.workload_metadata_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [workload_metadata_config][crate::model::UpdateNodePoolRequest::workload_metadata_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::WorkloadMetadataConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_workload_metadata_config(Some(WorkloadMetadataConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_workload_metadata_config(None::<WorkloadMetadataConfig>);
    /// ```
    pub fn set_or_clear_workload_metadata_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadMetadataConfig>,
    {
        self.workload_metadata_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [upgrade_settings][crate::model::UpdateNodePoolRequest::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = UpdateNodePoolRequest::new().set_upgrade_settings(UpgradeSettings::default()/* use setters */);
    /// ```
    pub fn set_upgrade_settings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [upgrade_settings][crate::model::UpdateNodePoolRequest::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_upgrade_settings(Some(UpgradeSettings::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_upgrade_settings(None::<UpgradeSettings>);
    /// ```
    pub fn set_or_clear_upgrade_settings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = v.map(|x| x.into());
        self
    }

    /// Sets the value of [tags][crate::model::UpdateNodePoolRequest::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = UpdateNodePoolRequest::new().set_tags(NetworkTags::default()/* use setters */);
    /// ```
    pub fn set_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [tags][crate::model::UpdateNodePoolRequest::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NetworkTags;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_tags(Some(NetworkTags::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_tags(None::<NetworkTags>);
    /// ```
    pub fn set_or_clear_tags<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkTags>,
    {
        self.tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [taints][crate::model::UpdateNodePoolRequest::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeTaints;
    /// let x = UpdateNodePoolRequest::new().set_taints(NodeTaints::default()/* use setters */);
    /// ```
    pub fn set_taints<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeTaints>,
    {
        self.taints = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [taints][crate::model::UpdateNodePoolRequest::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeTaints;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_taints(Some(NodeTaints::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_taints(None::<NodeTaints>);
    /// ```
    pub fn set_or_clear_taints<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeTaints>,
    {
        self.taints = v.map(|x| x.into());
        self
    }

    /// Sets the value of [labels][crate::model::UpdateNodePoolRequest::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeLabels;
    /// let x = UpdateNodePoolRequest::new().set_labels(NodeLabels::default()/* use setters */);
    /// ```
    pub fn set_labels<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeLabels>,
    {
        self.labels = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [labels][crate::model::UpdateNodePoolRequest::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeLabels;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_labels(Some(NodeLabels::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_labels(None::<NodeLabels>);
    /// ```
    pub fn set_or_clear_labels<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeLabels>,
    {
        self.labels = v.map(|x| x.into());
        self
    }

    /// Sets the value of [linux_node_config][crate::model::UpdateNodePoolRequest::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = UpdateNodePoolRequest::new().set_linux_node_config(LinuxNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_linux_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [linux_node_config][crate::model::UpdateNodePoolRequest::linux_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::LinuxNodeConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_linux_node_config(Some(LinuxNodeConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_linux_node_config(None::<LinuxNodeConfig>);
    /// ```
    pub fn set_or_clear_linux_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LinuxNodeConfig>,
    {
        self.linux_node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [kubelet_config][crate::model::UpdateNodePoolRequest::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = UpdateNodePoolRequest::new().set_kubelet_config(NodeKubeletConfig::default()/* use setters */);
    /// ```
    pub fn set_kubelet_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.kubelet_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [kubelet_config][crate::model::UpdateNodePoolRequest::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeKubeletConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_kubelet_config(None::<NodeKubeletConfig>);
    /// ```
    pub fn set_or_clear_kubelet_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeKubeletConfig>,
    {
        self.kubelet_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_network_config][crate::model::UpdateNodePoolRequest::node_network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = UpdateNodePoolRequest::new().set_node_network_config(NodeNetworkConfig::default()/* use setters */);
    /// ```
    pub fn set_node_network_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeNetworkConfig>,
    {
        self.node_network_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_network_config][crate::model::UpdateNodePoolRequest::node_network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_node_network_config(Some(NodeNetworkConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_node_network_config(None::<NodeNetworkConfig>);
    /// ```
    pub fn set_or_clear_node_network_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeNetworkConfig>,
    {
        self.node_network_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gcfs_config][crate::model::UpdateNodePoolRequest::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = UpdateNodePoolRequest::new().set_gcfs_config(GcfsConfig::default()/* use setters */);
    /// ```
    pub fn set_gcfs_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gcfs_config][crate::model::UpdateNodePoolRequest::gcfs_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::GcfsConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_gcfs_config(Some(GcfsConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_gcfs_config(None::<GcfsConfig>);
    /// ```
    pub fn set_or_clear_gcfs_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GcfsConfig>,
    {
        self.gcfs_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [confidential_nodes][crate::model::UpdateNodePoolRequest::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = UpdateNodePoolRequest::new().set_confidential_nodes(ConfidentialNodes::default()/* use setters */);
    /// ```
    pub fn set_confidential_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [confidential_nodes][crate::model::UpdateNodePoolRequest::confidential_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_confidential_nodes(Some(ConfidentialNodes::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_confidential_nodes(None::<ConfidentialNodes>);
    /// ```
    pub fn set_or_clear_confidential_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ConfidentialNodes>,
    {
        self.confidential_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gvnic][crate::model::UpdateNodePoolRequest::gvnic].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::VirtualNIC;
    /// let x = UpdateNodePoolRequest::new().set_gvnic(VirtualNIC::default()/* use setters */);
    /// ```
    pub fn set_gvnic<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::VirtualNIC>,
    {
        self.gvnic = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gvnic][crate::model::UpdateNodePoolRequest::gvnic].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::VirtualNIC;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_gvnic(Some(VirtualNIC::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_gvnic(None::<VirtualNIC>);
    /// ```
    pub fn set_or_clear_gvnic<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::VirtualNIC>,
    {
        self.gvnic = v.map(|x| x.into());
        self
    }

    /// Sets the value of [etag][crate::model::UpdateNodePoolRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }

    /// Sets the value of [fast_socket][crate::model::UpdateNodePoolRequest::fast_socket].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::FastSocket;
    /// let x = UpdateNodePoolRequest::new().set_fast_socket(FastSocket::default()/* use setters */);
    /// ```
    pub fn set_fast_socket<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::FastSocket>,
    {
        self.fast_socket = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [fast_socket][crate::model::UpdateNodePoolRequest::fast_socket].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::FastSocket;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_fast_socket(Some(FastSocket::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_fast_socket(None::<FastSocket>);
    /// ```
    pub fn set_or_clear_fast_socket<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::FastSocket>,
    {
        self.fast_socket = v.map(|x| x.into());
        self
    }

    /// Sets the value of [logging_config][crate::model::UpdateNodePoolRequest::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = UpdateNodePoolRequest::new().set_logging_config(NodePoolLoggingConfig::default()/* use setters */);
    /// ```
    pub fn set_logging_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [logging_config][crate::model::UpdateNodePoolRequest::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_logging_config(Some(NodePoolLoggingConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_logging_config(None::<NodePoolLoggingConfig>);
    /// ```
    pub fn set_or_clear_logging_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolLoggingConfig>,
    {
        self.logging_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_labels][crate::model::UpdateNodePoolRequest::resource_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ResourceLabels;
    /// let x = UpdateNodePoolRequest::new().set_resource_labels(ResourceLabels::default()/* use setters */);
    /// ```
    pub fn set_resource_labels<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceLabels>,
    {
        self.resource_labels = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [resource_labels][crate::model::UpdateNodePoolRequest::resource_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ResourceLabels;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_resource_labels(Some(ResourceLabels::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_resource_labels(None::<ResourceLabels>);
    /// ```
    pub fn set_or_clear_resource_labels<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResourceLabels>,
    {
        self.resource_labels = v.map(|x| x.into());
        self
    }

    /// Sets the value of [windows_node_config][crate::model::UpdateNodePoolRequest::windows_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::WindowsNodeConfig;
    /// let x = UpdateNodePoolRequest::new().set_windows_node_config(WindowsNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_windows_node_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WindowsNodeConfig>,
    {
        self.windows_node_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [windows_node_config][crate::model::UpdateNodePoolRequest::windows_node_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::WindowsNodeConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_windows_node_config(Some(WindowsNodeConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_windows_node_config(None::<WindowsNodeConfig>);
    /// ```
    pub fn set_or_clear_windows_node_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WindowsNodeConfig>,
    {
        self.windows_node_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [accelerators][crate::model::UpdateNodePoolRequest::accelerators].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::AcceleratorConfig;
    /// let x = UpdateNodePoolRequest::new()
    ///     .set_accelerators([
    ///         AcceleratorConfig::default()/* use setters */,
    ///         AcceleratorConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_accelerators<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AcceleratorConfig>,
    {
        use std::iter::Iterator;
        self.accelerators = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [machine_type][crate::model::UpdateNodePoolRequest::machine_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_machine_type("example");
    /// ```
    pub fn set_machine_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.machine_type = v.into();
        self
    }

    /// Sets the value of [disk_type][crate::model::UpdateNodePoolRequest::disk_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_disk_type("example");
    /// ```
    pub fn set_disk_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.disk_type = v.into();
        self
    }

    /// Sets the value of [disk_size_gb][crate::model::UpdateNodePoolRequest::disk_size_gb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_disk_size_gb(42);
    /// ```
    pub fn set_disk_size_gb<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.disk_size_gb = v.into();
        self
    }

    /// Sets the value of [resource_manager_tags][crate::model::UpdateNodePoolRequest::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = UpdateNodePoolRequest::new().set_resource_manager_tags(ResourceManagerTags::default()/* use setters */);
    /// ```
    pub fn set_resource_manager_tags<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [resource_manager_tags][crate::model::UpdateNodePoolRequest::resource_manager_tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_resource_manager_tags(Some(ResourceManagerTags::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_resource_manager_tags(None::<ResourceManagerTags>);
    /// ```
    pub fn set_or_clear_resource_manager_tags<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ResourceManagerTags>,
    {
        self.resource_manager_tags = v.map(|x| x.into());
        self
    }

    /// Sets the value of [containerd_config][crate::model::UpdateNodePoolRequest::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = UpdateNodePoolRequest::new().set_containerd_config(ContainerdConfig::default()/* use setters */);
    /// ```
    pub fn set_containerd_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [containerd_config][crate::model::UpdateNodePoolRequest::containerd_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::ContainerdConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_containerd_config(Some(ContainerdConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_containerd_config(None::<ContainerdConfig>);
    /// ```
    pub fn set_or_clear_containerd_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ContainerdConfig>,
    {
        self.containerd_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [queued_provisioning][crate::model::UpdateNodePoolRequest::queued_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::QueuedProvisioning;
    /// let x = UpdateNodePoolRequest::new().set_queued_provisioning(QueuedProvisioning::default()/* use setters */);
    /// ```
    pub fn set_queued_provisioning<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::QueuedProvisioning>,
    {
        self.queued_provisioning = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [queued_provisioning][crate::model::UpdateNodePoolRequest::queued_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::QueuedProvisioning;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_queued_provisioning(Some(QueuedProvisioning::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_queued_provisioning(None::<QueuedProvisioning>);
    /// ```
    pub fn set_or_clear_queued_provisioning<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::QueuedProvisioning>,
    {
        self.queued_provisioning = v.map(|x| x.into());
        self
    }

    /// Sets the value of [storage_pools][crate::model::UpdateNodePoolRequest::storage_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_storage_pools(["a", "b", "c"]);
    /// ```
    pub fn set_storage_pools<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.storage_pools = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [max_run_duration][crate::model::UpdateNodePoolRequest::max_run_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use wkt::Duration;
    /// let x = UpdateNodePoolRequest::new().set_max_run_duration(Duration::default()/* use setters */);
    /// ```
    pub fn set_max_run_duration<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_run_duration = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [max_run_duration][crate::model::UpdateNodePoolRequest::max_run_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use wkt::Duration;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_max_run_duration(Some(Duration::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_max_run_duration(None::<Duration>);
    /// ```
    pub fn set_or_clear_max_run_duration<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.max_run_duration = v.map(|x| x.into());
        self
    }

    /// Sets the value of [flex_start][crate::model::UpdateNodePoolRequest::flex_start].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_flex_start(true);
    /// ```
    pub fn set_flex_start<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.flex_start = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [flex_start][crate::model::UpdateNodePoolRequest::flex_start].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_flex_start(Some(false));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_flex_start(None::<bool>);
    /// ```
    pub fn set_or_clear_flex_start<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.flex_start = v.map(|x| x.into());
        self
    }

    /// Sets the value of [boot_disk][crate::model::UpdateNodePoolRequest::boot_disk].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::BootDisk;
    /// let x = UpdateNodePoolRequest::new().set_boot_disk(BootDisk::default()/* use setters */);
    /// ```
    pub fn set_boot_disk<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BootDisk>,
    {
        self.boot_disk = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [boot_disk][crate::model::UpdateNodePoolRequest::boot_disk].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::BootDisk;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_boot_disk(Some(BootDisk::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_boot_disk(None::<BootDisk>);
    /// ```
    pub fn set_or_clear_boot_disk<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BootDisk>,
    {
        self.boot_disk = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_drain_config][crate::model::UpdateNodePoolRequest::node_drain_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
    /// let x = UpdateNodePoolRequest::new().set_node_drain_config(NodeDrainConfig::default()/* use setters */);
    /// ```
    pub fn set_node_drain_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodeDrainConfig>,
    {
        self.node_drain_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_drain_config][crate::model::UpdateNodePoolRequest::node_drain_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_node_drain_config(Some(NodeDrainConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_node_drain_config(None::<NodeDrainConfig>);
    /// ```
    pub fn set_or_clear_node_drain_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodeDrainConfig>,
    {
        self.node_drain_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [consolidation_delay][crate::model::UpdateNodePoolRequest::consolidation_delay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use wkt::Duration;
    /// let x = UpdateNodePoolRequest::new().set_consolidation_delay(Duration::default()/* use setters */);
    /// ```
    pub fn set_consolidation_delay<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.consolidation_delay = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [consolidation_delay][crate::model::UpdateNodePoolRequest::consolidation_delay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use wkt::Duration;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_consolidation_delay(Some(Duration::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_consolidation_delay(None::<Duration>);
    /// ```
    pub fn set_or_clear_consolidation_delay<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.consolidation_delay = v.map(|x| x.into());
        self
    }

    /// Sets the value of [taint_config][crate::model::UpdateNodePoolRequest::taint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::TaintConfig;
    /// let x = UpdateNodePoolRequest::new().set_taint_config(TaintConfig::default()/* use setters */);
    /// ```
    pub fn set_taint_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TaintConfig>,
    {
        self.taint_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [taint_config][crate::model::UpdateNodePoolRequest::taint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateNodePoolRequest;
    /// use google_cloud_container_v1::model::TaintConfig;
    /// let x = UpdateNodePoolRequest::new().set_or_clear_taint_config(Some(TaintConfig::default()/* use setters */));
    /// let x = UpdateNodePoolRequest::new().set_or_clear_taint_config(None::<TaintConfig>);
    /// ```
    pub fn set_or_clear_taint_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TaintConfig>,
    {
        self.taint_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for UpdateNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpdateNodePoolRequest"
    }
}

/// SetNodePoolAutoscalingRequest sets the autoscaler settings of a node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetNodePoolAutoscalingRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// Required. Autoscaling configuration for the node pool.
    pub autoscaling: std::option::Option<crate::model::NodePoolAutoscaling>,

    /// The name (project, location, cluster, node pool) of the node pool to set
    /// autoscaler settings. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetNodePoolAutoscalingRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetNodePoolAutoscalingRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// let x = SetNodePoolAutoscalingRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetNodePoolAutoscalingRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// let x = SetNodePoolAutoscalingRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetNodePoolAutoscalingRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// let x = SetNodePoolAutoscalingRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::SetNodePoolAutoscalingRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// let x = SetNodePoolAutoscalingRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [autoscaling][crate::model::SetNodePoolAutoscalingRequest::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = SetNodePoolAutoscalingRequest::new().set_autoscaling(NodePoolAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autoscaling][crate::model::SetNodePoolAutoscalingRequest::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = SetNodePoolAutoscalingRequest::new().set_or_clear_autoscaling(Some(NodePoolAutoscaling::default()/* use setters */));
    /// let x = SetNodePoolAutoscalingRequest::new().set_or_clear_autoscaling(None::<NodePoolAutoscaling>);
    /// ```
    pub fn set_or_clear_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetNodePoolAutoscalingRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolAutoscalingRequest;
    /// let x = SetNodePoolAutoscalingRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetNodePoolAutoscalingRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetNodePoolAutoscalingRequest"
    }
}

/// SetLoggingServiceRequest sets the logging service of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetLoggingServiceRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The logging service the cluster should use to write logs.
    /// Currently available options:
    ///
    /// * `logging.googleapis.com/kubernetes` - The Cloud Logging
    ///   service with a Kubernetes-native resource model
    /// * `logging.googleapis.com` - The legacy Cloud Logging service (no longer
    ///   available as of GKE 1.15).
    /// * `none` - no logs will be exported from the cluster.
    ///
    /// If left as an empty string,`logging.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `logging.googleapis.com` for earlier versions.
    pub logging_service: std::string::String,

    /// The name (project, location, cluster) of the cluster to set logging.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetLoggingServiceRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetLoggingServiceRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLoggingServiceRequest;
    /// let x = SetLoggingServiceRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetLoggingServiceRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLoggingServiceRequest;
    /// let x = SetLoggingServiceRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetLoggingServiceRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLoggingServiceRequest;
    /// let x = SetLoggingServiceRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [logging_service][crate::model::SetLoggingServiceRequest::logging_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLoggingServiceRequest;
    /// let x = SetLoggingServiceRequest::new().set_logging_service("example");
    /// ```
    pub fn set_logging_service<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.logging_service = v.into();
        self
    }

    /// Sets the value of [name][crate::model::SetLoggingServiceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLoggingServiceRequest;
    /// let x = SetLoggingServiceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetLoggingServiceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetLoggingServiceRequest"
    }
}

/// SetMonitoringServiceRequest sets the monitoring service of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetMonitoringServiceRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The monitoring service the cluster should use to write metrics.
    /// Currently available options:
    ///
    /// * `monitoring.googleapis.com/kubernetes` - The Cloud Monitoring
    ///   service with a Kubernetes-native resource model
    /// * `monitoring.googleapis.com` - The legacy Cloud Monitoring service (no
    ///   longer available as of GKE 1.15).
    /// * `none` - No metrics will be exported from the cluster.
    ///
    /// If left as an empty string,`monitoring.googleapis.com/kubernetes` will be
    /// used for GKE 1.14+ or `monitoring.googleapis.com` for earlier versions.
    pub monitoring_service: std::string::String,

    /// The name (project, location, cluster) of the cluster to set monitoring.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetMonitoringServiceRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetMonitoringServiceRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMonitoringServiceRequest;
    /// let x = SetMonitoringServiceRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetMonitoringServiceRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMonitoringServiceRequest;
    /// let x = SetMonitoringServiceRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetMonitoringServiceRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMonitoringServiceRequest;
    /// let x = SetMonitoringServiceRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [monitoring_service][crate::model::SetMonitoringServiceRequest::monitoring_service].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMonitoringServiceRequest;
    /// let x = SetMonitoringServiceRequest::new().set_monitoring_service("example");
    /// ```
    pub fn set_monitoring_service<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.monitoring_service = v.into();
        self
    }

    /// Sets the value of [name][crate::model::SetMonitoringServiceRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMonitoringServiceRequest;
    /// let x = SetMonitoringServiceRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetMonitoringServiceRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetMonitoringServiceRequest"
    }
}

/// SetAddonsConfigRequest sets the addons associated with the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetAddonsConfigRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The desired configurations for the various addons available to
    /// run in the cluster.
    pub addons_config: std::option::Option<crate::model::AddonsConfig>,

    /// The name (project, location, cluster) of the cluster to set addons.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetAddonsConfigRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetAddonsConfigRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// let x = SetAddonsConfigRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetAddonsConfigRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// let x = SetAddonsConfigRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetAddonsConfigRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// let x = SetAddonsConfigRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [addons_config][crate::model::SetAddonsConfigRequest::addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = SetAddonsConfigRequest::new().set_addons_config(AddonsConfig::default()/* use setters */);
    /// ```
    pub fn set_addons_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.addons_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [addons_config][crate::model::SetAddonsConfigRequest::addons_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// use google_cloud_container_v1::model::AddonsConfig;
    /// let x = SetAddonsConfigRequest::new().set_or_clear_addons_config(Some(AddonsConfig::default()/* use setters */));
    /// let x = SetAddonsConfigRequest::new().set_or_clear_addons_config(None::<AddonsConfig>);
    /// ```
    pub fn set_or_clear_addons_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AddonsConfig>,
    {
        self.addons_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetAddonsConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetAddonsConfigRequest;
    /// let x = SetAddonsConfigRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetAddonsConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetAddonsConfigRequest"
    }
}

/// SetLocationsRequest sets the locations of the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetLocationsRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The desired list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster's nodes should be located. Changing the locations a
    /// cluster is in will result in nodes being either created or removed from the
    /// cluster, depending on whether locations are being added or removed.
    ///
    /// This list must always include the cluster's primary zone.
    pub locations: std::vec::Vec<std::string::String>,

    /// The name (project, location, cluster) of the cluster to set locations.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetLocationsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetLocationsRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLocationsRequest;
    /// let x = SetLocationsRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetLocationsRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLocationsRequest;
    /// let x = SetLocationsRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetLocationsRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLocationsRequest;
    /// let x = SetLocationsRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [locations][crate::model::SetLocationsRequest::locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLocationsRequest;
    /// let x = SetLocationsRequest::new().set_locations(["a", "b", "c"]);
    /// ```
    pub fn set_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [name][crate::model::SetLocationsRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLocationsRequest;
    /// let x = SetLocationsRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetLocationsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetLocationsRequest"
    }
}

/// UpdateMasterRequest updates the master of the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateMasterRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The Kubernetes version to change the master to.
    ///
    /// Users may specify either explicit versions offered by Kubernetes Engine or
    /// version aliases, which have the following behavior:
    ///
    /// - "latest": picks the highest valid Kubernetes version
    /// - "1.X": picks the highest valid patch+gke.N patch in the 1.X version
    /// - "1.X.Y": picks the highest valid gke.N patch in the 1.X.Y version
    /// - "1.X.Y-gke.N": picks an explicit Kubernetes version
    /// - "-": picks the default Kubernetes version
    pub master_version: std::string::String,

    /// The name (project, location, cluster) of the cluster to update.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateMasterRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::UpdateMasterRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateMasterRequest;
    /// let x = UpdateMasterRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::UpdateMasterRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateMasterRequest;
    /// let x = UpdateMasterRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::UpdateMasterRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateMasterRequest;
    /// let x = UpdateMasterRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [master_version][crate::model::UpdateMasterRequest::master_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateMasterRequest;
    /// let x = UpdateMasterRequest::new().set_master_version("example");
    /// ```
    pub fn set_master_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.master_version = v.into();
        self
    }

    /// Sets the value of [name][crate::model::UpdateMasterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpdateMasterRequest;
    /// let x = UpdateMasterRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for UpdateMasterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpdateMasterRequest"
    }
}

/// SetMasterAuthRequest updates the admin password of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetMasterAuthRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to upgrade.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The exact form of action to be taken on the master auth.
    pub action: crate::model::set_master_auth_request::Action,

    /// Required. A description of the update.
    pub update: std::option::Option<crate::model::MasterAuth>,

    /// The name (project, location, cluster) of the cluster to set auth.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetMasterAuthRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetMasterAuthRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// let x = SetMasterAuthRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetMasterAuthRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// let x = SetMasterAuthRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetMasterAuthRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// let x = SetMasterAuthRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [action][crate::model::SetMasterAuthRequest::action].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// use google_cloud_container_v1::model::set_master_auth_request::Action;
    /// let x0 = SetMasterAuthRequest::new().set_action(Action::SetPassword);
    /// let x1 = SetMasterAuthRequest::new().set_action(Action::GeneratePassword);
    /// let x2 = SetMasterAuthRequest::new().set_action(Action::SetUsername);
    /// ```
    pub fn set_action<T: std::convert::Into<crate::model::set_master_auth_request::Action>>(
        mut self,
        v: T,
    ) -> Self {
        self.action = v.into();
        self
    }

    /// Sets the value of [update][crate::model::SetMasterAuthRequest::update].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// use google_cloud_container_v1::model::MasterAuth;
    /// let x = SetMasterAuthRequest::new().set_update(MasterAuth::default()/* use setters */);
    /// ```
    pub fn set_update<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuth>,
    {
        self.update = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update][crate::model::SetMasterAuthRequest::update].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// use google_cloud_container_v1::model::MasterAuth;
    /// let x = SetMasterAuthRequest::new().set_or_clear_update(Some(MasterAuth::default()/* use setters */));
    /// let x = SetMasterAuthRequest::new().set_or_clear_update(None::<MasterAuth>);
    /// ```
    pub fn set_or_clear_update<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MasterAuth>,
    {
        self.update = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetMasterAuthRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMasterAuthRequest;
    /// let x = SetMasterAuthRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetMasterAuthRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetMasterAuthRequest"
    }
}

/// Defines additional types related to [SetMasterAuthRequest].
pub mod set_master_auth_request {
    #[allow(unused_imports)]
    use super::*;

    /// Operation type: what type update to perform.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Action {
        /// Operation is unknown and will error out.
        Unknown,
        /// Set the password to a user generated value.
        SetPassword,
        /// Generate a new password and set it to that.
        GeneratePassword,
        /// Set the username.  If an empty username is provided, basic authentication
        /// is disabled for the cluster.  If a non-empty username is provided, basic
        /// authentication is enabled, with either a provided password or a generated
        /// one.
        SetUsername,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Action::value] or
        /// [Action::name].
        UnknownValue(action::UnknownValue),
    }

    #[doc(hidden)]
    pub mod action {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Action {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::SetPassword => std::option::Option::Some(1),
                Self::GeneratePassword => std::option::Option::Some(2),
                Self::SetUsername => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::SetPassword => std::option::Option::Some("SET_PASSWORD"),
                Self::GeneratePassword => std::option::Option::Some("GENERATE_PASSWORD"),
                Self::SetUsername => std::option::Option::Some("SET_USERNAME"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Action {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Action {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Action {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::SetPassword,
                2 => Self::GeneratePassword,
                3 => Self::SetUsername,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Action {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "SET_PASSWORD" => Self::SetPassword,
                "GENERATE_PASSWORD" => Self::GeneratePassword,
                "SET_USERNAME" => Self::SetUsername,
                _ => Self::UnknownValue(action::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Action {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::SetPassword => serializer.serialize_i32(1),
                Self::GeneratePassword => serializer.serialize_i32(2),
                Self::SetUsername => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Action {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Action>::new(
                ".google.container.v1.SetMasterAuthRequest.Action",
            ))
        }
    }
}

/// DeleteClusterRequest deletes a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteClusterRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to delete.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// The name (project, location, cluster) of the cluster to delete.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteClusterRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::DeleteClusterRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteClusterRequest;
    /// let x = DeleteClusterRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::DeleteClusterRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteClusterRequest;
    /// let x = DeleteClusterRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::DeleteClusterRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteClusterRequest;
    /// let x = DeleteClusterRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::DeleteClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteClusterRequest;
    /// let x = DeleteClusterRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DeleteClusterRequest"
    }
}

/// ListClustersRequest lists clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListClustersRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides, or "-" for all zones. This field has been
    /// deprecated and replaced by the parent field.
    #[deprecated]
    pub zone: std::string::String,

    /// The parent (project and location) where the clusters will be listed.
    /// Specified in the format `projects/*/locations/*`.
    /// Location "-" matches all zones and all regions.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListClustersRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::ListClustersRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListClustersRequest;
    /// let x = ListClustersRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::ListClustersRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListClustersRequest;
    /// let x = ListClustersRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [parent][crate::model::ListClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListClustersRequest;
    /// let x = ListClustersRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for ListClustersRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListClustersRequest"
    }
}

/// ListClustersResponse is the result of ListClustersRequest.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListClustersResponse {
    /// A list of clusters in the project in the specified zone, or
    /// across all ones.
    pub clusters: std::vec::Vec<crate::model::Cluster>,

    /// If any zones are listed here, the list of clusters returned
    /// may be missing those zones.
    pub missing_zones: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListClustersResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [clusters][crate::model::ListClustersResponse::clusters].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListClustersResponse;
    /// use google_cloud_container_v1::model::Cluster;
    /// let x = ListClustersResponse::new()
    ///     .set_clusters([
    ///         Cluster::default()/* use setters */,
    ///         Cluster::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_clusters<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Cluster>,
    {
        use std::iter::Iterator;
        self.clusters = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [missing_zones][crate::model::ListClustersResponse::missing_zones].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListClustersResponse;
    /// let x = ListClustersResponse::new().set_missing_zones(["a", "b", "c"]);
    /// ```
    pub fn set_missing_zones<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.missing_zones = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListClustersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListClustersResponse"
    }
}

/// GetOperationRequest gets a single operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetOperationRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The server-assigned `name` of the operation.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub operation_id: std::string::String,

    /// The name (project, location, operation id) of the operation to get.
    /// Specified in the format `projects/*/locations/*/operations/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetOperationRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::GetOperationRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOperationRequest;
    /// let x = GetOperationRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::GetOperationRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOperationRequest;
    /// let x = GetOperationRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [operation_id][crate::model::GetOperationRequest::operation_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOperationRequest;
    /// let x = GetOperationRequest::new().set_operation_id("example");
    /// ```
    #[deprecated]
    pub fn set_operation_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.operation_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::GetOperationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOperationRequest;
    /// let x = GetOperationRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetOperationRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetOperationRequest"
    }
}

/// ListOperationsRequest lists operations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListOperationsRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// to return operations for, or `-` for all zones. This field has been
    /// deprecated and replaced by the parent field.
    #[deprecated]
    pub zone: std::string::String,

    /// The parent (project and location) where the operations will be listed.
    /// Specified in the format `projects/*/locations/*`.
    /// Location "-" matches all zones and all regions.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListOperationsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::ListOperationsRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListOperationsRequest;
    /// let x = ListOperationsRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::ListOperationsRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListOperationsRequest;
    /// let x = ListOperationsRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [parent][crate::model::ListOperationsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListOperationsRequest;
    /// let x = ListOperationsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for ListOperationsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListOperationsRequest"
    }
}

/// CancelOperationRequest cancels a single operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CancelOperationRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the operation resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The server-assigned `name` of the operation.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub operation_id: std::string::String,

    /// The name (project, location, operation id) of the operation to cancel.
    /// Specified in the format `projects/*/locations/*/operations/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CancelOperationRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::CancelOperationRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CancelOperationRequest;
    /// let x = CancelOperationRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::CancelOperationRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CancelOperationRequest;
    /// let x = CancelOperationRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [operation_id][crate::model::CancelOperationRequest::operation_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CancelOperationRequest;
    /// let x = CancelOperationRequest::new().set_operation_id("example");
    /// ```
    #[deprecated]
    pub fn set_operation_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.operation_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::CancelOperationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CancelOperationRequest;
    /// let x = CancelOperationRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for CancelOperationRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CancelOperationRequest"
    }
}

/// ListOperationsResponse is the result of ListOperationsRequest.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListOperationsResponse {
    /// A list of operations in the project in the specified zone.
    pub operations: std::vec::Vec<crate::model::Operation>,

    /// If any zones are listed here, the list of operations returned
    /// may be missing the operations from those zones.
    pub missing_zones: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListOperationsResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [operations][crate::model::ListOperationsResponse::operations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListOperationsResponse;
    /// use google_cloud_container_v1::model::Operation;
    /// let x = ListOperationsResponse::new()
    ///     .set_operations([
    ///         Operation::default()/* use setters */,
    ///         Operation::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_operations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Operation>,
    {
        use std::iter::Iterator;
        self.operations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [missing_zones][crate::model::ListOperationsResponse::missing_zones].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListOperationsResponse;
    /// let x = ListOperationsResponse::new().set_missing_zones(["a", "b", "c"]);
    /// ```
    pub fn set_missing_zones<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.missing_zones = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListOperationsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListOperationsResponse"
    }
}

/// Gets the current Kubernetes Engine service configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetServerConfigRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// to return operations for. This field has been deprecated and replaced by
    /// the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// The name (project and location) of the server config to get,
    /// specified in the format `projects/*/locations/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetServerConfigRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::GetServerConfigRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetServerConfigRequest;
    /// let x = GetServerConfigRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::GetServerConfigRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetServerConfigRequest;
    /// let x = GetServerConfigRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [name][crate::model::GetServerConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetServerConfigRequest;
    /// let x = GetServerConfigRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetServerConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetServerConfigRequest"
    }
}

/// Kubernetes Engine service configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServerConfig {
    /// Version of Kubernetes the service deploys by default.
    pub default_cluster_version: std::string::String,

    /// List of valid node upgrade target versions, in descending order.
    pub valid_node_versions: std::vec::Vec<std::string::String>,

    /// Default image type.
    pub default_image_type: std::string::String,

    /// List of valid image types.
    pub valid_image_types: std::vec::Vec<std::string::String>,

    /// List of valid master versions, in descending order.
    pub valid_master_versions: std::vec::Vec<std::string::String>,

    /// List of release channel configurations.
    pub channels: std::vec::Vec<crate::model::server_config::ReleaseChannelConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ServerConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [default_cluster_version][crate::model::ServerConfig::default_cluster_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// let x = ServerConfig::new().set_default_cluster_version("example");
    /// ```
    pub fn set_default_cluster_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_cluster_version = v.into();
        self
    }

    /// Sets the value of [valid_node_versions][crate::model::ServerConfig::valid_node_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// let x = ServerConfig::new().set_valid_node_versions(["a", "b", "c"]);
    /// ```
    pub fn set_valid_node_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.valid_node_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [default_image_type][crate::model::ServerConfig::default_image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// let x = ServerConfig::new().set_default_image_type("example");
    /// ```
    pub fn set_default_image_type<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.default_image_type = v.into();
        self
    }

    /// Sets the value of [valid_image_types][crate::model::ServerConfig::valid_image_types].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// let x = ServerConfig::new().set_valid_image_types(["a", "b", "c"]);
    /// ```
    pub fn set_valid_image_types<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.valid_image_types = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [valid_master_versions][crate::model::ServerConfig::valid_master_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// let x = ServerConfig::new().set_valid_master_versions(["a", "b", "c"]);
    /// ```
    pub fn set_valid_master_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.valid_master_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [channels][crate::model::ServerConfig::channels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServerConfig;
    /// use google_cloud_container_v1::model::server_config::ReleaseChannelConfig;
    /// let x = ServerConfig::new()
    ///     .set_channels([
    ///         ReleaseChannelConfig::default()/* use setters */,
    ///         ReleaseChannelConfig::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_channels<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::server_config::ReleaseChannelConfig>,
    {
        use std::iter::Iterator;
        self.channels = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ServerConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ServerConfig"
    }
}

/// Defines additional types related to [ServerConfig].
pub mod server_config {
    #[allow(unused_imports)]
    use super::*;

    /// ReleaseChannelConfig exposes configuration for a release channel.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ReleaseChannelConfig {
        /// The release channel this configuration applies to.
        pub channel: crate::model::release_channel::Channel,

        /// The default version for newly created clusters on the channel.
        pub default_version: std::string::String,

        /// List of valid versions for the channel.
        pub valid_versions: std::vec::Vec<std::string::String>,

        /// The auto upgrade target version for clusters on the channel.
        pub upgrade_target_version: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ReleaseChannelConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [channel][crate::model::server_config::ReleaseChannelConfig::channel].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::server_config::ReleaseChannelConfig;
        /// use google_cloud_container_v1::model::release_channel::Channel;
        /// let x0 = ReleaseChannelConfig::new().set_channel(Channel::Rapid);
        /// let x1 = ReleaseChannelConfig::new().set_channel(Channel::Regular);
        /// let x2 = ReleaseChannelConfig::new().set_channel(Channel::Stable);
        /// ```
        pub fn set_channel<T: std::convert::Into<crate::model::release_channel::Channel>>(
            mut self,
            v: T,
        ) -> Self {
            self.channel = v.into();
            self
        }

        /// Sets the value of [default_version][crate::model::server_config::ReleaseChannelConfig::default_version].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::server_config::ReleaseChannelConfig;
        /// let x = ReleaseChannelConfig::new().set_default_version("example");
        /// ```
        pub fn set_default_version<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.default_version = v.into();
            self
        }

        /// Sets the value of [valid_versions][crate::model::server_config::ReleaseChannelConfig::valid_versions].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::server_config::ReleaseChannelConfig;
        /// let x = ReleaseChannelConfig::new().set_valid_versions(["a", "b", "c"]);
        /// ```
        pub fn set_valid_versions<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<std::string::String>,
        {
            use std::iter::Iterator;
            self.valid_versions = v.into_iter().map(|i| i.into()).collect();
            self
        }

        /// Sets the value of [upgrade_target_version][crate::model::server_config::ReleaseChannelConfig::upgrade_target_version].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::server_config::ReleaseChannelConfig;
        /// let x = ReleaseChannelConfig::new().set_upgrade_target_version("example");
        /// ```
        pub fn set_upgrade_target_version<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.upgrade_target_version = v.into();
            self
        }
    }

    impl wkt::message::Message for ReleaseChannelConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ServerConfig.ReleaseChannelConfig"
        }
    }
}

/// CreateNodePoolRequest creates a node pool for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateNodePoolRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the parent field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The node pool to create.
    pub node_pool: std::option::Option<crate::model::NodePool>,

    /// The parent (project, location, cluster name) where the node pool will be
    /// created. Specified in the format
    /// `projects/*/locations/*/clusters/*`.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateNodePoolRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::CreateNodePoolRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// let x = CreateNodePoolRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::CreateNodePoolRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// let x = CreateNodePoolRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::CreateNodePoolRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// let x = CreateNodePoolRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool][crate::model::CreateNodePoolRequest::node_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodePool;
    /// let x = CreateNodePoolRequest::new().set_node_pool(NodePool::default()/* use setters */);
    /// ```
    pub fn set_node_pool<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePool>,
    {
        self.node_pool = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_pool][crate::model::CreateNodePoolRequest::node_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// use google_cloud_container_v1::model::NodePool;
    /// let x = CreateNodePoolRequest::new().set_or_clear_node_pool(Some(NodePool::default()/* use setters */));
    /// let x = CreateNodePoolRequest::new().set_or_clear_node_pool(None::<NodePool>);
    /// ```
    pub fn set_or_clear_node_pool<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePool>,
    {
        self.node_pool = v.map(|x| x.into());
        self
    }

    /// Sets the value of [parent][crate::model::CreateNodePoolRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CreateNodePoolRequest;
    /// let x = CreateNodePoolRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for CreateNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CreateNodePoolRequest"
    }
}

/// DeleteNodePoolRequest deletes a node pool for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteNodePoolRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to delete.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// The name (project, location, cluster, node pool id) of the node pool to
    /// delete. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteNodePoolRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::DeleteNodePoolRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteNodePoolRequest;
    /// let x = DeleteNodePoolRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::DeleteNodePoolRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteNodePoolRequest;
    /// let x = DeleteNodePoolRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::DeleteNodePoolRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteNodePoolRequest;
    /// let x = DeleteNodePoolRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::DeleteNodePoolRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteNodePoolRequest;
    /// let x = DeleteNodePoolRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::DeleteNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DeleteNodePoolRequest;
    /// let x = DeleteNodePoolRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for DeleteNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DeleteNodePoolRequest"
    }
}

/// ListNodePoolsRequest lists the node pool(s) for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListNodePoolsRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the parent field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the parent field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// The parent (project, location, cluster name) where the node pools will be
    /// listed. Specified in the format `projects/*/locations/*/clusters/*`.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListNodePoolsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::ListNodePoolsRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListNodePoolsRequest;
    /// let x = ListNodePoolsRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::ListNodePoolsRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListNodePoolsRequest;
    /// let x = ListNodePoolsRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::ListNodePoolsRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListNodePoolsRequest;
    /// let x = ListNodePoolsRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [parent][crate::model::ListNodePoolsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListNodePoolsRequest;
    /// let x = ListNodePoolsRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for ListNodePoolsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListNodePoolsRequest"
    }
}

/// GetNodePoolRequest retrieves a node pool for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetNodePoolRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// The name (project, location, cluster, node pool id) of the node pool to
    /// get. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetNodePoolRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::GetNodePoolRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetNodePoolRequest;
    /// let x = GetNodePoolRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::GetNodePoolRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetNodePoolRequest;
    /// let x = GetNodePoolRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::GetNodePoolRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetNodePoolRequest;
    /// let x = GetNodePoolRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::GetNodePoolRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetNodePoolRequest;
    /// let x = GetNodePoolRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::GetNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetNodePoolRequest;
    /// let x = GetNodePoolRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetNodePoolRequest"
    }
}

/// Settings for blue-green upgrade.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BlueGreenSettings {
    /// Time needed after draining entire blue pool. After this period, blue pool
    /// will be cleaned up.
    pub node_pool_soak_duration: std::option::Option<wkt::Duration>,

    /// The rollout policy controls the general rollout progress of blue-green.
    pub rollout_policy: std::option::Option<crate::model::blue_green_settings::RolloutPolicy>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BlueGreenSettings {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [node_pool_soak_duration][crate::model::BlueGreenSettings::node_pool_soak_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BlueGreenSettings;
    /// use wkt::Duration;
    /// let x = BlueGreenSettings::new().set_node_pool_soak_duration(Duration::default()/* use setters */);
    /// ```
    pub fn set_node_pool_soak_duration<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.node_pool_soak_duration = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_pool_soak_duration][crate::model::BlueGreenSettings::node_pool_soak_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BlueGreenSettings;
    /// use wkt::Duration;
    /// let x = BlueGreenSettings::new().set_or_clear_node_pool_soak_duration(Some(Duration::default()/* use setters */));
    /// let x = BlueGreenSettings::new().set_or_clear_node_pool_soak_duration(None::<Duration>);
    /// ```
    pub fn set_or_clear_node_pool_soak_duration<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.node_pool_soak_duration = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rollout_policy][crate::model::BlueGreenSettings::rollout_policy].
    ///
    /// Note that all the setters affecting `rollout_policy` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BlueGreenSettings;
    /// use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
    /// let x = BlueGreenSettings::new().set_rollout_policy(Some(
    ///     google_cloud_container_v1::model::blue_green_settings::RolloutPolicy::StandardRolloutPolicy(StandardRolloutPolicy::default().into())));
    /// ```
    pub fn set_rollout_policy<
        T: std::convert::Into<std::option::Option<crate::model::blue_green_settings::RolloutPolicy>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rollout_policy = v.into();
        self
    }

    /// The value of [rollout_policy][crate::model::BlueGreenSettings::rollout_policy]
    /// if it holds a `StandardRolloutPolicy`, `None` if the field is not set or
    /// holds a different branch.
    pub fn standard_rollout_policy(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::blue_green_settings::StandardRolloutPolicy>,
    > {
        #[allow(unreachable_patterns)]
        self.rollout_policy.as_ref().and_then(|v| match v {
            crate::model::blue_green_settings::RolloutPolicy::StandardRolloutPolicy(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rollout_policy][crate::model::BlueGreenSettings::rollout_policy]
    /// to hold a `StandardRolloutPolicy`.
    ///
    /// Note that all the setters affecting `rollout_policy` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BlueGreenSettings;
    /// use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
    /// let x = BlueGreenSettings::new().set_standard_rollout_policy(StandardRolloutPolicy::default()/* use setters */);
    /// assert!(x.standard_rollout_policy().is_some());
    /// assert!(x.autoscaled_rollout_policy().is_none());
    /// ```
    pub fn set_standard_rollout_policy<
        T: std::convert::Into<
                std::boxed::Box<crate::model::blue_green_settings::StandardRolloutPolicy>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rollout_policy = std::option::Option::Some(
            crate::model::blue_green_settings::RolloutPolicy::StandardRolloutPolicy(v.into()),
        );
        self
    }

    /// The value of [rollout_policy][crate::model::BlueGreenSettings::rollout_policy]
    /// if it holds a `AutoscaledRolloutPolicy`, `None` if the field is not set or
    /// holds a different branch.
    pub fn autoscaled_rollout_policy(
        &self,
    ) -> std::option::Option<
        &std::boxed::Box<crate::model::blue_green_settings::AutoscaledRolloutPolicy>,
    > {
        #[allow(unreachable_patterns)]
        self.rollout_policy.as_ref().and_then(|v| match v {
            crate::model::blue_green_settings::RolloutPolicy::AutoscaledRolloutPolicy(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [rollout_policy][crate::model::BlueGreenSettings::rollout_policy]
    /// to hold a `AutoscaledRolloutPolicy`.
    ///
    /// Note that all the setters affecting `rollout_policy` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BlueGreenSettings;
    /// use google_cloud_container_v1::model::blue_green_settings::AutoscaledRolloutPolicy;
    /// let x = BlueGreenSettings::new().set_autoscaled_rollout_policy(AutoscaledRolloutPolicy::default()/* use setters */);
    /// assert!(x.autoscaled_rollout_policy().is_some());
    /// assert!(x.standard_rollout_policy().is_none());
    /// ```
    pub fn set_autoscaled_rollout_policy<
        T: std::convert::Into<
                std::boxed::Box<crate::model::blue_green_settings::AutoscaledRolloutPolicy>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.rollout_policy = std::option::Option::Some(
            crate::model::blue_green_settings::RolloutPolicy::AutoscaledRolloutPolicy(v.into()),
        );
        self
    }
}

impl wkt::message::Message for BlueGreenSettings {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.BlueGreenSettings"
    }
}

/// Defines additional types related to [BlueGreenSettings].
pub mod blue_green_settings {
    #[allow(unused_imports)]
    use super::*;

    /// Standard rollout policy is the default policy for blue-green.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct StandardRolloutPolicy {
        /// Soak time after each batch gets drained. Default to zero.
        pub batch_soak_duration: std::option::Option<wkt::Duration>,

        /// Blue pool size to drain in a batch.
        pub update_batch_size: std::option::Option<
            crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize,
        >,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl StandardRolloutPolicy {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [batch_soak_duration][crate::model::blue_green_settings::StandardRolloutPolicy::batch_soak_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
        /// use wkt::Duration;
        /// let x = StandardRolloutPolicy::new().set_batch_soak_duration(Duration::default()/* use setters */);
        /// ```
        pub fn set_batch_soak_duration<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.batch_soak_duration = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [batch_soak_duration][crate::model::blue_green_settings::StandardRolloutPolicy::batch_soak_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
        /// use wkt::Duration;
        /// let x = StandardRolloutPolicy::new().set_or_clear_batch_soak_duration(Some(Duration::default()/* use setters */));
        /// let x = StandardRolloutPolicy::new().set_or_clear_batch_soak_duration(None::<Duration>);
        /// ```
        pub fn set_or_clear_batch_soak_duration<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.batch_soak_duration = v.map(|x| x.into());
            self
        }

        /// Sets the value of [update_batch_size][crate::model::blue_green_settings::StandardRolloutPolicy::update_batch_size].
        ///
        /// Note that all the setters affecting `update_batch_size` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
        /// use google_cloud_container_v1::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize;
        /// let x = StandardRolloutPolicy::new().set_update_batch_size(Some(UpdateBatchSize::BatchPercentage(42.0)));
        /// ```
        pub fn set_update_batch_size<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.update_batch_size = v.into();
            self
        }

        /// The value of [update_batch_size][crate::model::blue_green_settings::StandardRolloutPolicy::update_batch_size]
        /// if it holds a `BatchPercentage`, `None` if the field is not set or
        /// holds a different branch.
        pub fn batch_percentage(&self) -> std::option::Option<&f32> {
            #[allow(unreachable_patterns)]
            self.update_batch_size.as_ref().and_then(|v| match v {
                crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize::BatchPercentage(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [update_batch_size][crate::model::blue_green_settings::StandardRolloutPolicy::update_batch_size]
        /// to hold a `BatchPercentage`.
        ///
        /// Note that all the setters affecting `update_batch_size` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
        /// let x = StandardRolloutPolicy::new().set_batch_percentage(42.0);
        /// assert!(x.batch_percentage().is_some());
        /// assert!(x.batch_node_count().is_none());
        /// ```
        pub fn set_batch_percentage<T: std::convert::Into<f32>>(mut self, v: T) -> Self {
            self.update_batch_size = std::option::Option::Some(
                crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize::BatchPercentage(
                    v.into()
                )
            );
            self
        }

        /// The value of [update_batch_size][crate::model::blue_green_settings::StandardRolloutPolicy::update_batch_size]
        /// if it holds a `BatchNodeCount`, `None` if the field is not set or
        /// holds a different branch.
        pub fn batch_node_count(&self) -> std::option::Option<&i32> {
            #[allow(unreachable_patterns)]
            self.update_batch_size.as_ref().and_then(|v| match v {
                crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize::BatchNodeCount(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [update_batch_size][crate::model::blue_green_settings::StandardRolloutPolicy::update_batch_size]
        /// to hold a `BatchNodeCount`.
        ///
        /// Note that all the setters affecting `update_batch_size` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::StandardRolloutPolicy;
        /// let x = StandardRolloutPolicy::new().set_batch_node_count(42);
        /// assert!(x.batch_node_count().is_some());
        /// assert!(x.batch_percentage().is_none());
        /// ```
        pub fn set_batch_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.update_batch_size = std::option::Option::Some(
                crate::model::blue_green_settings::standard_rollout_policy::UpdateBatchSize::BatchNodeCount(
                    v.into()
                )
            );
            self
        }
    }

    impl wkt::message::Message for StandardRolloutPolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.BlueGreenSettings.StandardRolloutPolicy"
        }
    }

    /// Defines additional types related to [StandardRolloutPolicy].
    pub mod standard_rollout_policy {
        #[allow(unused_imports)]
        use super::*;

        /// Blue pool size to drain in a batch.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum UpdateBatchSize {
            /// Percentage of the blue pool nodes to drain in a batch.
            /// The range of this field should be (0.0, 1.0].
            BatchPercentage(f32),
            /// Number of blue nodes to drain in a batch.
            BatchNodeCount(i32),
        }
    }

    /// Autoscaled rollout policy utilizes the cluster autoscaler during
    /// blue-green upgrade to scale both the blue and green pools.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct AutoscaledRolloutPolicy {
        /// Optional. Time to wait after cordoning the blue pool before draining the
        /// nodes. Defaults to 3 days. The value can be set between 0 and 7 days,
        /// inclusive.
        pub wait_for_drain_duration: std::option::Option<wkt::Duration>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl AutoscaledRolloutPolicy {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [wait_for_drain_duration][crate::model::blue_green_settings::AutoscaledRolloutPolicy::wait_for_drain_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::AutoscaledRolloutPolicy;
        /// use wkt::Duration;
        /// let x = AutoscaledRolloutPolicy::new().set_wait_for_drain_duration(Duration::default()/* use setters */);
        /// ```
        pub fn set_wait_for_drain_duration<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.wait_for_drain_duration = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [wait_for_drain_duration][crate::model::blue_green_settings::AutoscaledRolloutPolicy::wait_for_drain_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::blue_green_settings::AutoscaledRolloutPolicy;
        /// use wkt::Duration;
        /// let x = AutoscaledRolloutPolicy::new().set_or_clear_wait_for_drain_duration(Some(Duration::default()/* use setters */));
        /// let x = AutoscaledRolloutPolicy::new().set_or_clear_wait_for_drain_duration(None::<Duration>);
        /// ```
        pub fn set_or_clear_wait_for_drain_duration<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.wait_for_drain_duration = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for AutoscaledRolloutPolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.BlueGreenSettings.AutoscaledRolloutPolicy"
        }
    }

    /// The rollout policy controls the general rollout progress of blue-green.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RolloutPolicy {
        /// Standard policy for the blue-green upgrade.
        StandardRolloutPolicy(
            std::boxed::Box<crate::model::blue_green_settings::StandardRolloutPolicy>,
        ),
        /// Autoscaled policy for cluster autoscaler enabled blue-green upgrade.
        AutoscaledRolloutPolicy(
            std::boxed::Box<crate::model::blue_green_settings::AutoscaledRolloutPolicy>,
        ),
    }
}

/// NodePool contains the name and configuration for a cluster's node pool.
/// Node pools are a set of nodes (i.e. VM's), with a common configuration and
/// specification, under the control of the cluster master. They may have a set
/// of Kubernetes labels applied to them, which may be used to reference them
/// during pod scheduling. They may also be resized up or down, to accommodate
/// the workload.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePool {
    /// The name of the node pool.
    pub name: std::string::String,

    /// The node configuration of the pool.
    pub config: std::option::Option<crate::model::NodeConfig>,

    /// The initial node count for the pool. You must ensure that your
    /// Compute Engine [resource
    /// quota](https://cloud.google.com/compute/quotas)
    /// is sufficient for this number of instances. You must also have available
    /// firewall and routes quota.
    pub initial_node_count: i32,

    /// The list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the NodePool's nodes should be located.
    ///
    /// If this value is unspecified during node pool creation, the
    /// [Cluster.Locations](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters#Cluster.FIELDS.locations)
    /// value will be used, instead.
    ///
    /// Warning: changing node pool locations will result in nodes being added
    /// and/or removed.
    pub locations: std::vec::Vec<std::string::String>,

    /// Networking configuration for this NodePool. If specified, it overrides the
    /// cluster-level defaults.
    pub network_config: std::option::Option<crate::model::NodeNetworkConfig>,

    /// Output only. Server-defined URL for the resource.
    pub self_link: std::string::String,

    /// The version of Kubernetes running on this NodePool's nodes. If unspecified,
    /// it defaults as described
    /// [here](https://cloud.google.com/kubernetes-engine/versioning#specifying_node_version).
    pub version: std::string::String,

    /// Output only. The resource URLs of the [managed instance
    /// groups](https://cloud.google.com/compute/docs/instance-groups/creating-groups-of-managed-instances)
    /// associated with this node pool.
    /// During the node pool blue-green upgrade operation, the URLs contain both
    /// blue and green resources.
    pub instance_group_urls: std::vec::Vec<std::string::String>,

    /// Output only. The status of the nodes in this pool instance.
    pub status: crate::model::node_pool::Status,

    /// Output only. Deprecated. Use conditions instead.
    /// Additional information about the current status of this
    /// node pool instance, if available.
    #[deprecated]
    pub status_message: std::string::String,

    /// Autoscaler configuration for this NodePool. Autoscaler is enabled
    /// only if a valid configuration is present.
    pub autoscaling: std::option::Option<crate::model::NodePoolAutoscaling>,

    /// NodeManagement configuration for this NodePool.
    pub management: std::option::Option<crate::model::NodeManagement>,

    /// The constraint on the maximum number of pods that can be run
    /// simultaneously on a node in the node pool.
    pub max_pods_constraint: std::option::Option<crate::model::MaxPodsConstraint>,

    /// Which conditions caused the current node pool state.
    pub conditions: std::vec::Vec<crate::model::StatusCondition>,

    /// Output only. The pod CIDR block size per node in this node pool.
    pub pod_ipv4_cidr_size: i32,

    /// Upgrade settings control disruption and speed of the upgrade.
    pub upgrade_settings: std::option::Option<crate::model::node_pool::UpgradeSettings>,

    /// Specifies the node placement policy.
    pub placement_policy: std::option::Option<crate::model::node_pool::PlacementPolicy>,

    /// Output only. Update info contains relevant information during a node
    /// pool update.
    pub update_info: std::option::Option<crate::model::node_pool::UpdateInfo>,

    /// This checksum is computed by the server based on the value of node pool
    /// fields, and may be sent on update requests to ensure the client has an
    /// up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Specifies the configuration of queued provisioning.
    pub queued_provisioning: std::option::Option<crate::model::node_pool::QueuedProvisioning>,

    /// Enable best effort provisioning for nodes
    pub best_effort_provisioning: std::option::Option<crate::model::BestEffortProvisioning>,

    /// Specifies the node drain configuration for this node pool.
    pub node_drain_config: std::option::Option<crate::model::node_pool::NodeDrainConfig>,

    /// Optional. Specifies the maintenance policy for the node pool.
    pub maintenance_policy: std::option::Option<crate::model::node_pool::NodePoolMaintenancePolicy>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePool {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::NodePool::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [config][crate::model::NodePool::config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodePool::new().set_config(NodeConfig::default()/* use setters */);
    /// ```
    pub fn set_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfig>,
    {
        self.config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [config][crate::model::NodePool::config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeConfig;
    /// let x = NodePool::new().set_or_clear_config(Some(NodeConfig::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_config(None::<NodeConfig>);
    /// ```
    pub fn set_or_clear_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeConfig>,
    {
        self.config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [initial_node_count][crate::model::NodePool::initial_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_initial_node_count(42);
    /// ```
    pub fn set_initial_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.initial_node_count = v.into();
        self
    }

    /// Sets the value of [locations][crate::model::NodePool::locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_locations(["a", "b", "c"]);
    /// ```
    pub fn set_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [network_config][crate::model::NodePool::network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodePool::new().set_network_config(NodeNetworkConfig::default()/* use setters */);
    /// ```
    pub fn set_network_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeNetworkConfig>,
    {
        self.network_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_config][crate::model::NodePool::network_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeNetworkConfig;
    /// let x = NodePool::new().set_or_clear_network_config(Some(NodeNetworkConfig::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_network_config(None::<NodeNetworkConfig>);
    /// ```
    pub fn set_or_clear_network_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeNetworkConfig>,
    {
        self.network_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [self_link][crate::model::NodePool::self_link].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_self_link("example");
    /// ```
    pub fn set_self_link<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.self_link = v.into();
        self
    }

    /// Sets the value of [version][crate::model::NodePool::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_version("example");
    /// ```
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

    /// Sets the value of [instance_group_urls][crate::model::NodePool::instance_group_urls].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_instance_group_urls(["a", "b", "c"]);
    /// ```
    pub fn set_instance_group_urls<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.instance_group_urls = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [status][crate::model::NodePool::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::Status;
    /// let x0 = NodePool::new().set_status(Status::Provisioning);
    /// let x1 = NodePool::new().set_status(Status::Running);
    /// let x2 = NodePool::new().set_status(Status::RunningWithError);
    /// ```
    pub fn set_status<T: std::convert::Into<crate::model::node_pool::Status>>(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::NodePool::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_status_message("example");
    /// ```
    #[deprecated]
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [autoscaling][crate::model::NodePool::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePool::new().set_autoscaling(NodePoolAutoscaling::default()/* use setters */);
    /// ```
    pub fn set_autoscaling<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.autoscaling = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autoscaling][crate::model::NodePool::autoscaling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePool::new().set_or_clear_autoscaling(Some(NodePoolAutoscaling::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_autoscaling(None::<NodePoolAutoscaling>);
    /// ```
    pub fn set_or_clear_autoscaling<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodePoolAutoscaling>,
    {
        self.autoscaling = v.map(|x| x.into());
        self
    }

    /// Sets the value of [management][crate::model::NodePool::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = NodePool::new().set_management(NodeManagement::default()/* use setters */);
    /// ```
    pub fn set_management<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [management][crate::model::NodePool::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = NodePool::new().set_or_clear_management(Some(NodeManagement::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_management(None::<NodeManagement>);
    /// ```
    pub fn set_or_clear_management<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = v.map(|x| x.into());
        self
    }

    /// Sets the value of [max_pods_constraint][crate::model::NodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = NodePool::new().set_max_pods_constraint(MaxPodsConstraint::default()/* use setters */);
    /// ```
    pub fn set_max_pods_constraint<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.max_pods_constraint = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [max_pods_constraint][crate::model::NodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = NodePool::new().set_or_clear_max_pods_constraint(Some(MaxPodsConstraint::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_max_pods_constraint(None::<MaxPodsConstraint>);
    /// ```
    pub fn set_or_clear_max_pods_constraint<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaxPodsConstraint>,
    {
        self.max_pods_constraint = v.map(|x| x.into());
        self
    }

    /// Sets the value of [conditions][crate::model::NodePool::conditions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::StatusCondition;
    /// let x = NodePool::new()
    ///     .set_conditions([
    ///         StatusCondition::default()/* use setters */,
    ///         StatusCondition::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_conditions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::StatusCondition>,
    {
        use std::iter::Iterator;
        self.conditions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [pod_ipv4_cidr_size][crate::model::NodePool::pod_ipv4_cidr_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_pod_ipv4_cidr_size(42);
    /// ```
    pub fn set_pod_ipv4_cidr_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.pod_ipv4_cidr_size = v.into();
        self
    }

    /// Sets the value of [upgrade_settings][crate::model::NodePool::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = NodePool::new().set_upgrade_settings(UpgradeSettings::default()/* use setters */);
    /// ```
    pub fn set_upgrade_settings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [upgrade_settings][crate::model::NodePool::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = NodePool::new().set_or_clear_upgrade_settings(Some(UpgradeSettings::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_upgrade_settings(None::<UpgradeSettings>);
    /// ```
    pub fn set_or_clear_upgrade_settings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = v.map(|x| x.into());
        self
    }

    /// Sets the value of [placement_policy][crate::model::NodePool::placement_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::PlacementPolicy;
    /// let x = NodePool::new().set_placement_policy(PlacementPolicy::default()/* use setters */);
    /// ```
    pub fn set_placement_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::PlacementPolicy>,
    {
        self.placement_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [placement_policy][crate::model::NodePool::placement_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::PlacementPolicy;
    /// let x = NodePool::new().set_or_clear_placement_policy(Some(PlacementPolicy::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_placement_policy(None::<PlacementPolicy>);
    /// ```
    pub fn set_or_clear_placement_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::PlacementPolicy>,
    {
        self.placement_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_info][crate::model::NodePool::update_info].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::UpdateInfo;
    /// let x = NodePool::new().set_update_info(UpdateInfo::default()/* use setters */);
    /// ```
    pub fn set_update_info<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpdateInfo>,
    {
        self.update_info = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_info][crate::model::NodePool::update_info].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::UpdateInfo;
    /// let x = NodePool::new().set_or_clear_update_info(Some(UpdateInfo::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_update_info(None::<UpdateInfo>);
    /// ```
    pub fn set_or_clear_update_info<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpdateInfo>,
    {
        self.update_info = v.map(|x| x.into());
        self
    }

    /// Sets the value of [etag][crate::model::NodePool::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// let x = NodePool::new().set_etag("example");
    /// ```
    pub fn set_etag<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.etag = v.into();
        self
    }

    /// Sets the value of [queued_provisioning][crate::model::NodePool::queued_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::QueuedProvisioning;
    /// let x = NodePool::new().set_queued_provisioning(QueuedProvisioning::default()/* use setters */);
    /// ```
    pub fn set_queued_provisioning<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::QueuedProvisioning>,
    {
        self.queued_provisioning = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [queued_provisioning][crate::model::NodePool::queued_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::QueuedProvisioning;
    /// let x = NodePool::new().set_or_clear_queued_provisioning(Some(QueuedProvisioning::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_queued_provisioning(None::<QueuedProvisioning>);
    /// ```
    pub fn set_or_clear_queued_provisioning<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::QueuedProvisioning>,
    {
        self.queued_provisioning = v.map(|x| x.into());
        self
    }

    /// Sets the value of [best_effort_provisioning][crate::model::NodePool::best_effort_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::BestEffortProvisioning;
    /// let x = NodePool::new().set_best_effort_provisioning(BestEffortProvisioning::default()/* use setters */);
    /// ```
    pub fn set_best_effort_provisioning<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BestEffortProvisioning>,
    {
        self.best_effort_provisioning = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [best_effort_provisioning][crate::model::NodePool::best_effort_provisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::BestEffortProvisioning;
    /// let x = NodePool::new().set_or_clear_best_effort_provisioning(Some(BestEffortProvisioning::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_best_effort_provisioning(None::<BestEffortProvisioning>);
    /// ```
    pub fn set_or_clear_best_effort_provisioning<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BestEffortProvisioning>,
    {
        self.best_effort_provisioning = v.map(|x| x.into());
        self
    }

    /// Sets the value of [node_drain_config][crate::model::NodePool::node_drain_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
    /// let x = NodePool::new().set_node_drain_config(NodeDrainConfig::default()/* use setters */);
    /// ```
    pub fn set_node_drain_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodeDrainConfig>,
    {
        self.node_drain_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [node_drain_config][crate::model::NodePool::node_drain_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
    /// let x = NodePool::new().set_or_clear_node_drain_config(Some(NodeDrainConfig::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_node_drain_config(None::<NodeDrainConfig>);
    /// ```
    pub fn set_or_clear_node_drain_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodeDrainConfig>,
    {
        self.node_drain_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [maintenance_policy][crate::model::NodePool::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::NodePoolMaintenancePolicy;
    /// let x = NodePool::new().set_maintenance_policy(NodePoolMaintenancePolicy::default()/* use setters */);
    /// ```
    pub fn set_maintenance_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodePoolMaintenancePolicy>,
    {
        self.maintenance_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [maintenance_policy][crate::model::NodePool::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePool;
    /// use google_cloud_container_v1::model::node_pool::NodePoolMaintenancePolicy;
    /// let x = NodePool::new().set_or_clear_maintenance_policy(Some(NodePoolMaintenancePolicy::default()/* use setters */));
    /// let x = NodePool::new().set_or_clear_maintenance_policy(None::<NodePoolMaintenancePolicy>);
    /// ```
    pub fn set_or_clear_maintenance_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::NodePoolMaintenancePolicy>,
    {
        self.maintenance_policy = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodePool {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePool"
    }
}

/// Defines additional types related to [NodePool].
pub mod node_pool {
    #[allow(unused_imports)]
    use super::*;

    /// These upgrade settings control the level of parallelism and the level of
    /// disruption caused by an upgrade.
    ///
    /// maxUnavailable controls the number of nodes that can be simultaneously
    /// unavailable.
    ///
    /// maxSurge controls the number of additional nodes that can be added to the
    /// node pool temporarily for the time of the upgrade to increase the number of
    /// available nodes.
    ///
    /// (maxUnavailable + maxSurge) determines the level of parallelism (how many
    /// nodes are being upgraded at the same time).
    ///
    /// Note: upgrades inevitably introduce some disruption since workloads need to
    /// be moved from old nodes to new, upgraded ones. Even if maxUnavailable=0,
    /// this holds true. (Disruption stays within the limits of
    /// PodDisruptionBudget, if it is configured.)
    ///
    /// Consider a hypothetical node pool with 5 nodes having maxSurge=2,
    /// maxUnavailable=1. This means the upgrade process upgrades 3 nodes
    /// simultaneously. It creates 2 additional (upgraded) nodes, then it brings
    /// down 3 old (not yet upgraded) nodes at the same time. This ensures that
    /// there are always at least 4 nodes available.
    ///
    /// These upgrade settings configure the upgrade strategy for the node pool.
    /// Use strategy to switch between the strategies applied to the node pool.
    ///
    /// If the strategy is ROLLING, use max_surge and max_unavailable to control
    /// the level of parallelism and the level of disruption caused by upgrade.
    ///
    /// 1. maxSurge controls the number of additional nodes that can be added to
    ///    the node pool temporarily for the time of the upgrade to increase the
    ///    number of available nodes.
    /// 1. maxUnavailable controls the number of nodes that can be simultaneously
    ///    unavailable.
    /// 1. (maxUnavailable + maxSurge) determines the level of parallelism (how
    ///    many nodes are being upgraded at the same time).
    ///
    /// If the strategy is BLUE_GREEN, use blue_green_settings to configure the
    /// blue-green upgrade related settings.
    ///
    /// 1. standard_rollout_policy is the default policy. The policy is used to
    ///    control the way blue pool gets drained. The draining is executed in the
    ///    batch mode. The batch size could be specified as either percentage of the
    ///    node pool size or the number of nodes. batch_soak_duration is the soak
    ///    time after each batch gets drained.
    /// 1. node_pool_soak_duration is the soak time after all blue nodes are
    ///    drained. After this period, the blue pool nodes will be deleted.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct UpgradeSettings {
        /// The maximum number of nodes that can be created beyond the current size
        /// of the node pool during the upgrade process.
        pub max_surge: i32,

        /// The maximum number of nodes that can be simultaneously unavailable during
        /// the upgrade process. A node is considered available if its status is
        /// Ready.
        pub max_unavailable: i32,

        /// Update strategy of the node pool.
        pub strategy: std::option::Option<crate::model::NodePoolUpdateStrategy>,

        /// Settings for blue-green upgrade strategy.
        pub blue_green_settings: std::option::Option<crate::model::BlueGreenSettings>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl UpgradeSettings {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [max_surge][crate::model::node_pool::UpgradeSettings::max_surge].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// let x = UpgradeSettings::new().set_max_surge(42);
        /// ```
        pub fn set_max_surge<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.max_surge = v.into();
            self
        }

        /// Sets the value of [max_unavailable][crate::model::node_pool::UpgradeSettings::max_unavailable].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// let x = UpgradeSettings::new().set_max_unavailable(42);
        /// ```
        pub fn set_max_unavailable<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
            self.max_unavailable = v.into();
            self
        }

        /// Sets the value of [strategy][crate::model::node_pool::UpgradeSettings::strategy].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// use google_cloud_container_v1::model::NodePoolUpdateStrategy;
        /// let x0 = UpgradeSettings::new().set_strategy(NodePoolUpdateStrategy::BlueGreen);
        /// let x1 = UpgradeSettings::new().set_strategy(NodePoolUpdateStrategy::Surge);
        /// let x2 = UpgradeSettings::new().set_strategy(NodePoolUpdateStrategy::ShortLived);
        /// ```
        pub fn set_strategy<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::NodePoolUpdateStrategy>,
        {
            self.strategy = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [strategy][crate::model::node_pool::UpgradeSettings::strategy].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// use google_cloud_container_v1::model::NodePoolUpdateStrategy;
        /// let x0 = UpgradeSettings::new().set_or_clear_strategy(Some(NodePoolUpdateStrategy::BlueGreen));
        /// let x1 = UpgradeSettings::new().set_or_clear_strategy(Some(NodePoolUpdateStrategy::Surge));
        /// let x2 = UpgradeSettings::new().set_or_clear_strategy(Some(NodePoolUpdateStrategy::ShortLived));
        /// let x_none = UpgradeSettings::new().set_or_clear_strategy(None::<NodePoolUpdateStrategy>);
        /// ```
        pub fn set_or_clear_strategy<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::NodePoolUpdateStrategy>,
        {
            self.strategy = v.map(|x| x.into());
            self
        }

        /// Sets the value of [blue_green_settings][crate::model::node_pool::UpgradeSettings::blue_green_settings].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// use google_cloud_container_v1::model::BlueGreenSettings;
        /// let x = UpgradeSettings::new().set_blue_green_settings(BlueGreenSettings::default()/* use setters */);
        /// ```
        pub fn set_blue_green_settings<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::BlueGreenSettings>,
        {
            self.blue_green_settings = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [blue_green_settings][crate::model::node_pool::UpgradeSettings::blue_green_settings].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpgradeSettings;
        /// use google_cloud_container_v1::model::BlueGreenSettings;
        /// let x = UpgradeSettings::new().set_or_clear_blue_green_settings(Some(BlueGreenSettings::default()/* use setters */));
        /// let x = UpgradeSettings::new().set_or_clear_blue_green_settings(None::<BlueGreenSettings>);
        /// ```
        pub fn set_or_clear_blue_green_settings<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::BlueGreenSettings>,
        {
            self.blue_green_settings = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for UpgradeSettings {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.UpgradeSettings"
        }
    }

    /// UpdateInfo contains resource (instance groups, etc), status and other
    /// intermediate information relevant to a node pool upgrade.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct UpdateInfo {
        /// Information of a blue-green upgrade.
        pub blue_green_info:
            std::option::Option<crate::model::node_pool::update_info::BlueGreenInfo>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl UpdateInfo {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [blue_green_info][crate::model::node_pool::UpdateInfo::blue_green_info].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpdateInfo;
        /// use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
        /// let x = UpdateInfo::new().set_blue_green_info(BlueGreenInfo::default()/* use setters */);
        /// ```
        pub fn set_blue_green_info<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::node_pool::update_info::BlueGreenInfo>,
        {
            self.blue_green_info = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [blue_green_info][crate::model::node_pool::UpdateInfo::blue_green_info].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::UpdateInfo;
        /// use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
        /// let x = UpdateInfo::new().set_or_clear_blue_green_info(Some(BlueGreenInfo::default()/* use setters */));
        /// let x = UpdateInfo::new().set_or_clear_blue_green_info(None::<BlueGreenInfo>);
        /// ```
        pub fn set_or_clear_blue_green_info<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::node_pool::update_info::BlueGreenInfo>,
        {
            self.blue_green_info = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for UpdateInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.UpdateInfo"
        }
    }

    /// Defines additional types related to [UpdateInfo].
    pub mod update_info {
        #[allow(unused_imports)]
        use super::*;

        /// Information relevant to blue-green upgrade.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct BlueGreenInfo {
            /// Current blue-green upgrade phase.
            pub phase: crate::model::node_pool::update_info::blue_green_info::Phase,

            /// The resource URLs of the [managed instance groups]
            /// (/compute/docs/instance-groups/creating-groups-of-managed-instances)
            /// associated with blue pool.
            pub blue_instance_group_urls: std::vec::Vec<std::string::String>,

            /// The resource URLs of the [managed instance groups]
            /// (/compute/docs/instance-groups/creating-groups-of-managed-instances)
            /// associated with green pool.
            pub green_instance_group_urls: std::vec::Vec<std::string::String>,

            /// Time to start deleting blue pool to complete blue-green upgrade,
            /// in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
            pub blue_pool_deletion_start_time: std::string::String,

            /// Version of green pool.
            pub green_pool_version: std::string::String,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl BlueGreenInfo {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [phase][crate::model::node_pool::update_info::BlueGreenInfo::phase].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
            /// use google_cloud_container_v1::model::node_pool::update_info::blue_green_info::Phase;
            /// let x0 = BlueGreenInfo::new().set_phase(Phase::UpdateStarted);
            /// let x1 = BlueGreenInfo::new().set_phase(Phase::CreatingGreenPool);
            /// let x2 = BlueGreenInfo::new().set_phase(Phase::CordoningBluePool);
            /// ```
            pub fn set_phase<
                T: std::convert::Into<crate::model::node_pool::update_info::blue_green_info::Phase>,
            >(
                mut self,
                v: T,
            ) -> Self {
                self.phase = v.into();
                self
            }

            /// Sets the value of [blue_instance_group_urls][crate::model::node_pool::update_info::BlueGreenInfo::blue_instance_group_urls].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
            /// let x = BlueGreenInfo::new().set_blue_instance_group_urls(["a", "b", "c"]);
            /// ```
            pub fn set_blue_instance_group_urls<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.blue_instance_group_urls = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [green_instance_group_urls][crate::model::node_pool::update_info::BlueGreenInfo::green_instance_group_urls].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
            /// let x = BlueGreenInfo::new().set_green_instance_group_urls(["a", "b", "c"]);
            /// ```
            pub fn set_green_instance_group_urls<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.green_instance_group_urls = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [blue_pool_deletion_start_time][crate::model::node_pool::update_info::BlueGreenInfo::blue_pool_deletion_start_time].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
            /// let x = BlueGreenInfo::new().set_blue_pool_deletion_start_time("example");
            /// ```
            pub fn set_blue_pool_deletion_start_time<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.blue_pool_deletion_start_time = v.into();
                self
            }

            /// Sets the value of [green_pool_version][crate::model::node_pool::update_info::BlueGreenInfo::green_pool_version].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_container_v1::model::node_pool::update_info::BlueGreenInfo;
            /// let x = BlueGreenInfo::new().set_green_pool_version("example");
            /// ```
            pub fn set_green_pool_version<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.green_pool_version = v.into();
                self
            }
        }

        impl wkt::message::Message for BlueGreenInfo {
            fn typename() -> &'static str {
                "type.googleapis.com/google.container.v1.NodePool.UpdateInfo.BlueGreenInfo"
            }
        }

        /// Defines additional types related to [BlueGreenInfo].
        pub mod blue_green_info {
            #[allow(unused_imports)]
            use super::*;

            /// Phase represents the different stages blue-green upgrade is running in.
            ///
            /// # Working with unknown values
            ///
            /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
            /// additional enum variants at any time. Adding new variants is not considered
            /// a breaking change. Applications should write their code in anticipation of:
            ///
            /// - New values appearing in future releases of the client library, **and**
            /// - New values received dynamically, without application changes.
            ///
            /// Please consult the [Working with enums] section in the user guide for some
            /// guidelines.
            ///
            /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum Phase {
                /// Unspecified phase.
                Unspecified,
                /// blue-green upgrade has been initiated.
                UpdateStarted,
                /// Start creating green pool nodes.
                CreatingGreenPool,
                /// Start cordoning blue pool nodes.
                CordoningBluePool,
                /// Start draining blue pool nodes.
                DrainingBluePool,
                /// Start soaking time after draining entire blue pool.
                NodePoolSoaking,
                /// Start deleting blue nodes.
                DeletingBluePool,
                /// Rollback has been initiated.
                RollbackStarted,
                /// If set, the enum was initialized with an unknown value.
                ///
                /// Applications can examine the value using [Phase::value] or
                /// [Phase::name].
                UnknownValue(phase::UnknownValue),
            }

            #[doc(hidden)]
            pub mod phase {
                #[allow(unused_imports)]
                use super::*;
                #[derive(Clone, Debug, PartialEq)]
                pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
            }

            impl Phase {
                /// Gets the enum value.
                ///
                /// Returns `None` if the enum contains an unknown value deserialized from
                /// the string representation of enums.
                pub fn value(&self) -> std::option::Option<i32> {
                    match self {
                        Self::Unspecified => std::option::Option::Some(0),
                        Self::UpdateStarted => std::option::Option::Some(1),
                        Self::CreatingGreenPool => std::option::Option::Some(2),
                        Self::CordoningBluePool => std::option::Option::Some(3),
                        Self::DrainingBluePool => std::option::Option::Some(4),
                        Self::NodePoolSoaking => std::option::Option::Some(5),
                        Self::DeletingBluePool => std::option::Option::Some(6),
                        Self::RollbackStarted => std::option::Option::Some(7),
                        Self::UnknownValue(u) => u.0.value(),
                    }
                }

                /// Gets the enum value as a string.
                ///
                /// Returns `None` if the enum contains an unknown value deserialized from
                /// the integer representation of enums.
                pub fn name(&self) -> std::option::Option<&str> {
                    match self {
                        Self::Unspecified => std::option::Option::Some("PHASE_UNSPECIFIED"),
                        Self::UpdateStarted => std::option::Option::Some("UPDATE_STARTED"),
                        Self::CreatingGreenPool => std::option::Option::Some("CREATING_GREEN_POOL"),
                        Self::CordoningBluePool => std::option::Option::Some("CORDONING_BLUE_POOL"),
                        Self::DrainingBluePool => std::option::Option::Some("DRAINING_BLUE_POOL"),
                        Self::NodePoolSoaking => std::option::Option::Some("NODE_POOL_SOAKING"),
                        Self::DeletingBluePool => std::option::Option::Some("DELETING_BLUE_POOL"),
                        Self::RollbackStarted => std::option::Option::Some("ROLLBACK_STARTED"),
                        Self::UnknownValue(u) => u.0.name(),
                    }
                }
            }

            impl std::default::Default for Phase {
                fn default() -> Self {
                    use std::convert::From;
                    Self::from(0)
                }
            }

            impl std::fmt::Display for Phase {
                fn fmt(
                    &self,
                    f: &mut std::fmt::Formatter<'_>,
                ) -> std::result::Result<(), std::fmt::Error> {
                    wkt::internal::display_enum(f, self.name(), self.value())
                }
            }

            impl std::convert::From<i32> for Phase {
                fn from(value: i32) -> Self {
                    match value {
                        0 => Self::Unspecified,
                        1 => Self::UpdateStarted,
                        2 => Self::CreatingGreenPool,
                        3 => Self::CordoningBluePool,
                        4 => Self::DrainingBluePool,
                        5 => Self::NodePoolSoaking,
                        6 => Self::DeletingBluePool,
                        7 => Self::RollbackStarted,
                        _ => Self::UnknownValue(phase::UnknownValue(
                            wkt::internal::UnknownEnumValue::Integer(value),
                        )),
                    }
                }
            }

            impl std::convert::From<&str> for Phase {
                fn from(value: &str) -> Self {
                    use std::string::ToString;
                    match value {
                        "PHASE_UNSPECIFIED" => Self::Unspecified,
                        "UPDATE_STARTED" => Self::UpdateStarted,
                        "CREATING_GREEN_POOL" => Self::CreatingGreenPool,
                        "CORDONING_BLUE_POOL" => Self::CordoningBluePool,
                        "DRAINING_BLUE_POOL" => Self::DrainingBluePool,
                        "NODE_POOL_SOAKING" => Self::NodePoolSoaking,
                        "DELETING_BLUE_POOL" => Self::DeletingBluePool,
                        "ROLLBACK_STARTED" => Self::RollbackStarted,
                        _ => Self::UnknownValue(phase::UnknownValue(
                            wkt::internal::UnknownEnumValue::String(value.to_string()),
                        )),
                    }
                }
            }

            impl serde::ser::Serialize for Phase {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::Serializer,
                {
                    match self {
                        Self::Unspecified => serializer.serialize_i32(0),
                        Self::UpdateStarted => serializer.serialize_i32(1),
                        Self::CreatingGreenPool => serializer.serialize_i32(2),
                        Self::CordoningBluePool => serializer.serialize_i32(3),
                        Self::DrainingBluePool => serializer.serialize_i32(4),
                        Self::NodePoolSoaking => serializer.serialize_i32(5),
                        Self::DeletingBluePool => serializer.serialize_i32(6),
                        Self::RollbackStarted => serializer.serialize_i32(7),
                        Self::UnknownValue(u) => u.0.serialize(serializer),
                    }
                }
            }

            impl<'de> serde::de::Deserialize<'de> for Phase {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    deserializer.deserialize_any(wkt::internal::EnumVisitor::<Phase>::new(
                        ".google.container.v1.NodePool.UpdateInfo.BlueGreenInfo.Phase",
                    ))
                }
            }
        }
    }

    /// PlacementPolicy defines the placement policy used by the node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PlacementPolicy {
        /// The type of placement.
        pub r#type: crate::model::node_pool::placement_policy::Type,

        /// Optional. TPU placement topology for pod slice node pool.
        /// <https://cloud.google.com/tpu/docs/types-topologies#tpu_topologies>
        pub tpu_topology: std::string::String,

        /// If set, refers to the name of a custom resource policy supplied by the
        /// user. The resource policy must be in the same project and region as the
        /// node pool. If not found, InvalidArgument error is returned.
        pub policy_name: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl PlacementPolicy {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [r#type][crate::model::node_pool::PlacementPolicy::type].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::PlacementPolicy;
        /// use google_cloud_container_v1::model::node_pool::placement_policy::Type;
        /// let x0 = PlacementPolicy::new().set_type(Type::Compact);
        /// ```
        pub fn set_type<T: std::convert::Into<crate::model::node_pool::placement_policy::Type>>(
            mut self,
            v: T,
        ) -> Self {
            self.r#type = v.into();
            self
        }

        /// Sets the value of [tpu_topology][crate::model::node_pool::PlacementPolicy::tpu_topology].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::PlacementPolicy;
        /// let x = PlacementPolicy::new().set_tpu_topology("example");
        /// ```
        pub fn set_tpu_topology<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.tpu_topology = v.into();
            self
        }

        /// Sets the value of [policy_name][crate::model::node_pool::PlacementPolicy::policy_name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::PlacementPolicy;
        /// let x = PlacementPolicy::new().set_policy_name("example");
        /// ```
        pub fn set_policy_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.policy_name = v.into();
            self
        }
    }

    impl wkt::message::Message for PlacementPolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.PlacementPolicy"
        }
    }

    /// Defines additional types related to [PlacementPolicy].
    pub mod placement_policy {
        #[allow(unused_imports)]
        use super::*;

        /// Type defines the type of placement policy.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Type {
            /// TYPE_UNSPECIFIED specifies no requirements on nodes
            /// placement.
            Unspecified,
            /// COMPACT specifies node placement in the same availability domain to
            /// ensure low communication latency.
            Compact,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Type::value] or
            /// [Type::name].
            UnknownValue(r#type::UnknownValue),
        }

        #[doc(hidden)]
        pub mod r#type {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Type {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Compact => std::option::Option::Some(1),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("TYPE_UNSPECIFIED"),
                    Self::Compact => std::option::Option::Some("COMPACT"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Type {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Type {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Type {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Compact,
                    _ => Self::UnknownValue(r#type::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Type {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "TYPE_UNSPECIFIED" => Self::Unspecified,
                    "COMPACT" => Self::Compact,
                    _ => Self::UnknownValue(r#type::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Type {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Compact => serializer.serialize_i32(1),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Type {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Type>::new(
                    ".google.container.v1.NodePool.PlacementPolicy.Type",
                ))
            }
        }
    }

    /// QueuedProvisioning defines the queued provisioning used by the node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct QueuedProvisioning {
        /// Denotes that this node pool is QRM specific, meaning nodes can be only
        /// obtained through queuing via the Cluster Autoscaler ProvisioningRequest
        /// API.
        pub enabled: bool,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl QueuedProvisioning {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::node_pool::QueuedProvisioning::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::QueuedProvisioning;
        /// let x = QueuedProvisioning::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }
    }

    impl wkt::message::Message for QueuedProvisioning {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.QueuedProvisioning"
        }
    }

    /// NodeDrainConfig contains the node drain related configurations for this
    /// node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NodeDrainConfig {
        /// The duration of the PDB timeout period for node drain.
        pub pdb_timeout_duration: std::option::Option<wkt::Duration>,

        /// The duration of the grace termination period for node drain.
        pub grace_termination_duration: std::option::Option<wkt::Duration>,

        /// Whether to respect PDB during node pool deletion.
        pub respect_pdb_during_node_pool_deletion: std::option::Option<bool>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NodeDrainConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [pdb_timeout_duration][crate::model::node_pool::NodeDrainConfig::pdb_timeout_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// use wkt::Duration;
        /// let x = NodeDrainConfig::new().set_pdb_timeout_duration(Duration::default()/* use setters */);
        /// ```
        pub fn set_pdb_timeout_duration<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.pdb_timeout_duration = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [pdb_timeout_duration][crate::model::node_pool::NodeDrainConfig::pdb_timeout_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// use wkt::Duration;
        /// let x = NodeDrainConfig::new().set_or_clear_pdb_timeout_duration(Some(Duration::default()/* use setters */));
        /// let x = NodeDrainConfig::new().set_or_clear_pdb_timeout_duration(None::<Duration>);
        /// ```
        pub fn set_or_clear_pdb_timeout_duration<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.pdb_timeout_duration = v.map(|x| x.into());
            self
        }

        /// Sets the value of [grace_termination_duration][crate::model::node_pool::NodeDrainConfig::grace_termination_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// use wkt::Duration;
        /// let x = NodeDrainConfig::new().set_grace_termination_duration(Duration::default()/* use setters */);
        /// ```
        pub fn set_grace_termination_duration<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.grace_termination_duration = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [grace_termination_duration][crate::model::node_pool::NodeDrainConfig::grace_termination_duration].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// use wkt::Duration;
        /// let x = NodeDrainConfig::new().set_or_clear_grace_termination_duration(Some(Duration::default()/* use setters */));
        /// let x = NodeDrainConfig::new().set_or_clear_grace_termination_duration(None::<Duration>);
        /// ```
        pub fn set_or_clear_grace_termination_duration<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.grace_termination_duration = v.map(|x| x.into());
            self
        }

        /// Sets the value of [respect_pdb_during_node_pool_deletion][crate::model::node_pool::NodeDrainConfig::respect_pdb_during_node_pool_deletion].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// let x = NodeDrainConfig::new().set_respect_pdb_during_node_pool_deletion(true);
        /// ```
        pub fn set_respect_pdb_during_node_pool_deletion<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.respect_pdb_during_node_pool_deletion = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [respect_pdb_during_node_pool_deletion][crate::model::node_pool::NodeDrainConfig::respect_pdb_during_node_pool_deletion].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodeDrainConfig;
        /// let x = NodeDrainConfig::new().set_or_clear_respect_pdb_during_node_pool_deletion(Some(false));
        /// let x = NodeDrainConfig::new().set_or_clear_respect_pdb_during_node_pool_deletion(None::<bool>);
        /// ```
        pub fn set_or_clear_respect_pdb_during_node_pool_deletion<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.respect_pdb_during_node_pool_deletion = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for NodeDrainConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.NodeDrainConfig"
        }
    }

    /// Defines the maintenance exclusion for the node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ExclusionUntilEndOfSupport {
        /// Optional. Indicates whether the exclusion is enabled.
        pub enabled: bool,

        /// Output only. The start time of the maintenance exclusion. It is output
        /// only. It is the exclusion creation time.
        pub start_time: std::option::Option<wkt::Timestamp>,

        /// Output only. The end time of the maintenance exclusion. It is output
        /// only. It is the cluster control plane version's end of support time, or
        /// end of extended support time when the cluster is on extended support
        /// channel.
        pub end_time: std::option::Option<wkt::Timestamp>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ExclusionUntilEndOfSupport {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::node_pool::ExclusionUntilEndOfSupport::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// let x = ExclusionUntilEndOfSupport::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }

        /// Sets the value of [start_time][crate::model::node_pool::ExclusionUntilEndOfSupport::start_time].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// use wkt::Timestamp;
        /// let x = ExclusionUntilEndOfSupport::new().set_start_time(Timestamp::default()/* use setters */);
        /// ```
        pub fn set_start_time<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.start_time = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [start_time][crate::model::node_pool::ExclusionUntilEndOfSupport::start_time].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// use wkt::Timestamp;
        /// let x = ExclusionUntilEndOfSupport::new().set_or_clear_start_time(Some(Timestamp::default()/* use setters */));
        /// let x = ExclusionUntilEndOfSupport::new().set_or_clear_start_time(None::<Timestamp>);
        /// ```
        pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.start_time = v.map(|x| x.into());
            self
        }

        /// Sets the value of [end_time][crate::model::node_pool::ExclusionUntilEndOfSupport::end_time].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// use wkt::Timestamp;
        /// let x = ExclusionUntilEndOfSupport::new().set_end_time(Timestamp::default()/* use setters */);
        /// ```
        pub fn set_end_time<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.end_time = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [end_time][crate::model::node_pool::ExclusionUntilEndOfSupport::end_time].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// use wkt::Timestamp;
        /// let x = ExclusionUntilEndOfSupport::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
        /// let x = ExclusionUntilEndOfSupport::new().set_or_clear_end_time(None::<Timestamp>);
        /// ```
        pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.end_time = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ExclusionUntilEndOfSupport {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.ExclusionUntilEndOfSupport"
        }
    }

    /// Defines the maintenance policy for the node pool.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct NodePoolMaintenancePolicy {
        /// Optional. The exclusion until end of support for the node pool.
        pub exclusion_until_end_of_support:
            std::option::Option<crate::model::node_pool::ExclusionUntilEndOfSupport>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl NodePoolMaintenancePolicy {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [exclusion_until_end_of_support][crate::model::node_pool::NodePoolMaintenancePolicy::exclusion_until_end_of_support].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodePoolMaintenancePolicy;
        /// use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// let x = NodePoolMaintenancePolicy::new().set_exclusion_until_end_of_support(ExclusionUntilEndOfSupport::default()/* use setters */);
        /// ```
        pub fn set_exclusion_until_end_of_support<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::node_pool::ExclusionUntilEndOfSupport>,
        {
            self.exclusion_until_end_of_support = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [exclusion_until_end_of_support][crate::model::node_pool::NodePoolMaintenancePolicy::exclusion_until_end_of_support].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::node_pool::NodePoolMaintenancePolicy;
        /// use google_cloud_container_v1::model::node_pool::ExclusionUntilEndOfSupport;
        /// let x = NodePoolMaintenancePolicy::new().set_or_clear_exclusion_until_end_of_support(Some(ExclusionUntilEndOfSupport::default()/* use setters */));
        /// let x = NodePoolMaintenancePolicy::new().set_or_clear_exclusion_until_end_of_support(None::<ExclusionUntilEndOfSupport>);
        /// ```
        pub fn set_or_clear_exclusion_until_end_of_support<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<crate::model::node_pool::ExclusionUntilEndOfSupport>,
        {
            self.exclusion_until_end_of_support = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for NodePoolMaintenancePolicy {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NodePool.NodePoolMaintenancePolicy"
        }
    }

    /// The current status of the node pool instance.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Status {
        /// Not set.
        Unspecified,
        /// The PROVISIONING state indicates the node pool is being created.
        Provisioning,
        /// The RUNNING state indicates the node pool has been created
        /// and is fully usable.
        Running,
        /// The RUNNING_WITH_ERROR state indicates the node pool has been created
        /// and is partially usable. Some error state has occurred and some
        /// functionality may be impaired. Customer may need to reissue a request
        /// or trigger a new update.
        RunningWithError,
        /// The RECONCILING state indicates that some work is actively being done on
        /// the node pool, such as upgrading node software. Details can
        /// be found in the `statusMessage` field.
        Reconciling,
        /// The STOPPING state indicates the node pool is being deleted.
        Stopping,
        /// The ERROR state indicates the node pool may be unusable. Details
        /// can be found in the `statusMessage` field.
        Error,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Status::value] or
        /// [Status::name].
        UnknownValue(status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Status {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Provisioning => std::option::Option::Some(1),
                Self::Running => std::option::Option::Some(2),
                Self::RunningWithError => std::option::Option::Some(3),
                Self::Reconciling => std::option::Option::Some(4),
                Self::Stopping => std::option::Option::Some(5),
                Self::Error => std::option::Option::Some(6),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATUS_UNSPECIFIED"),
                Self::Provisioning => std::option::Option::Some("PROVISIONING"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::RunningWithError => std::option::Option::Some("RUNNING_WITH_ERROR"),
                Self::Reconciling => std::option::Option::Some("RECONCILING"),
                Self::Stopping => std::option::Option::Some("STOPPING"),
                Self::Error => std::option::Option::Some("ERROR"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Status {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Status {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Status {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Provisioning,
                2 => Self::Running,
                3 => Self::RunningWithError,
                4 => Self::Reconciling,
                5 => Self::Stopping,
                6 => Self::Error,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Status {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATUS_UNSPECIFIED" => Self::Unspecified,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RUNNING_WITH_ERROR" => Self::RunningWithError,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Status {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Provisioning => serializer.serialize_i32(1),
                Self::Running => serializer.serialize_i32(2),
                Self::RunningWithError => serializer.serialize_i32(3),
                Self::Reconciling => serializer.serialize_i32(4),
                Self::Stopping => serializer.serialize_i32(5),
                Self::Error => serializer.serialize_i32(6),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Status {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Status>::new(
                ".google.container.v1.NodePool.Status",
            ))
        }
    }
}

/// NodeManagement defines the set of node management services turned on for the
/// node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeManagement {
    /// A flag that specifies whether node auto-upgrade is enabled for the node
    /// pool. If enabled, node auto-upgrade helps keep the nodes in your node pool
    /// up to date with the latest release version of Kubernetes.
    pub auto_upgrade: bool,

    /// A flag that specifies whether the node auto-repair is enabled for the node
    /// pool. If enabled, the nodes in this node pool will be monitored and, if
    /// they fail health checks too many times, an automatic repair action will be
    /// triggered.
    pub auto_repair: bool,

    /// Specifies the Auto Upgrade knobs for the node pool.
    pub upgrade_options: std::option::Option<crate::model::AutoUpgradeOptions>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodeManagement {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auto_upgrade][crate::model::NodeManagement::auto_upgrade].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeManagement;
    /// let x = NodeManagement::new().set_auto_upgrade(true);
    /// ```
    pub fn set_auto_upgrade<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.auto_upgrade = v.into();
        self
    }

    /// Sets the value of [auto_repair][crate::model::NodeManagement::auto_repair].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeManagement;
    /// let x = NodeManagement::new().set_auto_repair(true);
    /// ```
    pub fn set_auto_repair<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.auto_repair = v.into();
        self
    }

    /// Sets the value of [upgrade_options][crate::model::NodeManagement::upgrade_options].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeManagement;
    /// use google_cloud_container_v1::model::AutoUpgradeOptions;
    /// let x = NodeManagement::new().set_upgrade_options(AutoUpgradeOptions::default()/* use setters */);
    /// ```
    pub fn set_upgrade_options<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AutoUpgradeOptions>,
    {
        self.upgrade_options = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [upgrade_options][crate::model::NodeManagement::upgrade_options].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodeManagement;
    /// use google_cloud_container_v1::model::AutoUpgradeOptions;
    /// let x = NodeManagement::new().set_or_clear_upgrade_options(Some(AutoUpgradeOptions::default()/* use setters */));
    /// let x = NodeManagement::new().set_or_clear_upgrade_options(None::<AutoUpgradeOptions>);
    /// ```
    pub fn set_or_clear_upgrade_options<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AutoUpgradeOptions>,
    {
        self.upgrade_options = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodeManagement {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodeManagement"
    }
}

/// Best effort provisioning.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BestEffortProvisioning {
    /// When this is enabled, cluster/node pool creations will ignore non-fatal
    /// errors like stockout to best provision as many nodes as possible right now
    /// and eventually bring up all target number of nodes
    pub enabled: bool,

    /// Minimum number of nodes to be provisioned to be considered as succeeded,
    /// and the rest of nodes will be provisioned gradually and eventually when
    /// stockout issue has been resolved.
    pub min_provision_nodes: i32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BestEffortProvisioning {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::BestEffortProvisioning::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BestEffortProvisioning;
    /// let x = BestEffortProvisioning::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [min_provision_nodes][crate::model::BestEffortProvisioning::min_provision_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BestEffortProvisioning;
    /// let x = BestEffortProvisioning::new().set_min_provision_nodes(42);
    /// ```
    pub fn set_min_provision_nodes<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.min_provision_nodes = v.into();
        self
    }
}

impl wkt::message::Message for BestEffortProvisioning {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.BestEffortProvisioning"
    }
}

/// AutoUpgradeOptions defines the set of options for the user to control how
/// the Auto Upgrades will proceed.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AutoUpgradeOptions {
    /// Output only. This field is set when upgrades are about to commence
    /// with the approximate start time for the upgrades, in
    /// [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format.
    pub auto_upgrade_start_time: std::string::String,

    /// Output only. This field is set when upgrades are about to commence
    /// with the description of the upgrade.
    pub description: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AutoUpgradeOptions {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auto_upgrade_start_time][crate::model::AutoUpgradeOptions::auto_upgrade_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoUpgradeOptions;
    /// let x = AutoUpgradeOptions::new().set_auto_upgrade_start_time("example");
    /// ```
    pub fn set_auto_upgrade_start_time<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.auto_upgrade_start_time = v.into();
        self
    }

    /// Sets the value of [description][crate::model::AutoUpgradeOptions::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoUpgradeOptions;
    /// let x = AutoUpgradeOptions::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }
}

impl wkt::message::Message for AutoUpgradeOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AutoUpgradeOptions"
    }
}

/// MaintenancePolicy defines the maintenance policy to be used for the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaintenancePolicy {
    /// Specifies the maintenance window in which maintenance may be performed.
    pub window: std::option::Option<crate::model::MaintenanceWindow>,

    /// A hash identifying the version of this policy, so that updates to fields of
    /// the policy won't accidentally undo intermediate changes (and so that users
    /// of the API unaware of some fields won't accidentally remove other fields).
    /// Make a `get()` request to the cluster to get the current
    /// resource version and include it with requests to set the policy.
    pub resource_version: std::string::String,

    /// Optional. The upgrade disruption budget for the cluster control plane.
    pub disruption_budget: std::option::Option<crate::model::DisruptionBudget>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaintenancePolicy {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [window][crate::model::MaintenancePolicy::window].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenancePolicy;
    /// use google_cloud_container_v1::model::MaintenanceWindow;
    /// let x = MaintenancePolicy::new().set_window(MaintenanceWindow::default()/* use setters */);
    /// ```
    pub fn set_window<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaintenanceWindow>,
    {
        self.window = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [window][crate::model::MaintenancePolicy::window].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenancePolicy;
    /// use google_cloud_container_v1::model::MaintenanceWindow;
    /// let x = MaintenancePolicy::new().set_or_clear_window(Some(MaintenanceWindow::default()/* use setters */));
    /// let x = MaintenancePolicy::new().set_or_clear_window(None::<MaintenanceWindow>);
    /// ```
    pub fn set_or_clear_window<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaintenanceWindow>,
    {
        self.window = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource_version][crate::model::MaintenancePolicy::resource_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenancePolicy;
    /// let x = MaintenancePolicy::new().set_resource_version("example");
    /// ```
    pub fn set_resource_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.resource_version = v.into();
        self
    }

    /// Sets the value of [disruption_budget][crate::model::MaintenancePolicy::disruption_budget].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenancePolicy;
    /// use google_cloud_container_v1::model::DisruptionBudget;
    /// let x = MaintenancePolicy::new().set_disruption_budget(DisruptionBudget::default()/* use setters */);
    /// ```
    pub fn set_disruption_budget<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DisruptionBudget>,
    {
        self.disruption_budget = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [disruption_budget][crate::model::MaintenancePolicy::disruption_budget].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenancePolicy;
    /// use google_cloud_container_v1::model::DisruptionBudget;
    /// let x = MaintenancePolicy::new().set_or_clear_disruption_budget(Some(DisruptionBudget::default()/* use setters */));
    /// let x = MaintenancePolicy::new().set_or_clear_disruption_budget(None::<DisruptionBudget>);
    /// ```
    pub fn set_or_clear_disruption_budget<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DisruptionBudget>,
    {
        self.disruption_budget = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for MaintenancePolicy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MaintenancePolicy"
    }
}

/// DisruptionBudget defines the upgrade disruption budget for the cluster
/// control plane.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DisruptionBudget {
    /// Optional. The minimum duration between two minor version upgrades of the
    /// control plane.
    pub minor_version_disruption_interval: std::option::Option<wkt::Duration>,

    /// Optional. The minimum duration between two patch version upgrades of the
    /// control plane.
    pub patch_version_disruption_interval: std::option::Option<wkt::Duration>,

    /// Output only. The last time a minor version upgrade was performed on the
    /// control plane.
    pub last_minor_version_disruption_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The last time a disruption was performed on the control plane.
    pub last_disruption_time: std::option::Option<wkt::Timestamp>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DisruptionBudget {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [minor_version_disruption_interval][crate::model::DisruptionBudget::minor_version_disruption_interval].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Duration;
    /// let x = DisruptionBudget::new().set_minor_version_disruption_interval(Duration::default()/* use setters */);
    /// ```
    pub fn set_minor_version_disruption_interval<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.minor_version_disruption_interval = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [minor_version_disruption_interval][crate::model::DisruptionBudget::minor_version_disruption_interval].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Duration;
    /// let x = DisruptionBudget::new().set_or_clear_minor_version_disruption_interval(Some(Duration::default()/* use setters */));
    /// let x = DisruptionBudget::new().set_or_clear_minor_version_disruption_interval(None::<Duration>);
    /// ```
    pub fn set_or_clear_minor_version_disruption_interval<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.minor_version_disruption_interval = v.map(|x| x.into());
        self
    }

    /// Sets the value of [patch_version_disruption_interval][crate::model::DisruptionBudget::patch_version_disruption_interval].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Duration;
    /// let x = DisruptionBudget::new().set_patch_version_disruption_interval(Duration::default()/* use setters */);
    /// ```
    pub fn set_patch_version_disruption_interval<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.patch_version_disruption_interval = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [patch_version_disruption_interval][crate::model::DisruptionBudget::patch_version_disruption_interval].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Duration;
    /// let x = DisruptionBudget::new().set_or_clear_patch_version_disruption_interval(Some(Duration::default()/* use setters */));
    /// let x = DisruptionBudget::new().set_or_clear_patch_version_disruption_interval(None::<Duration>);
    /// ```
    pub fn set_or_clear_patch_version_disruption_interval<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.patch_version_disruption_interval = v.map(|x| x.into());
        self
    }

    /// Sets the value of [last_minor_version_disruption_time][crate::model::DisruptionBudget::last_minor_version_disruption_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Timestamp;
    /// let x = DisruptionBudget::new().set_last_minor_version_disruption_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_last_minor_version_disruption_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_minor_version_disruption_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [last_minor_version_disruption_time][crate::model::DisruptionBudget::last_minor_version_disruption_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Timestamp;
    /// let x = DisruptionBudget::new().set_or_clear_last_minor_version_disruption_time(Some(Timestamp::default()/* use setters */));
    /// let x = DisruptionBudget::new().set_or_clear_last_minor_version_disruption_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_last_minor_version_disruption_time<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_minor_version_disruption_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [last_disruption_time][crate::model::DisruptionBudget::last_disruption_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Timestamp;
    /// let x = DisruptionBudget::new().set_last_disruption_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_last_disruption_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_disruption_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [last_disruption_time][crate::model::DisruptionBudget::last_disruption_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionBudget;
    /// use wkt::Timestamp;
    /// let x = DisruptionBudget::new().set_or_clear_last_disruption_time(Some(Timestamp::default()/* use setters */));
    /// let x = DisruptionBudget::new().set_or_clear_last_disruption_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_last_disruption_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_disruption_time = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for DisruptionBudget {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DisruptionBudget"
    }
}

/// MaintenanceWindow defines the maintenance window to be used for the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaintenanceWindow {
    /// Exceptions to maintenance window. Non-emergency maintenance should not
    /// occur in these windows.
    pub maintenance_exclusions:
        std::collections::HashMap<std::string::String, crate::model::TimeWindow>,

    #[allow(missing_docs)]
    pub policy: std::option::Option<crate::model::maintenance_window::Policy>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaintenanceWindow {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [maintenance_exclusions][crate::model::MaintenanceWindow::maintenance_exclusions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceWindow;
    /// use google_cloud_container_v1::model::TimeWindow;
    /// let x = MaintenanceWindow::new().set_maintenance_exclusions([
    ///     ("key0", TimeWindow::default()/* use setters */),
    ///     ("key1", TimeWindow::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_maintenance_exclusions<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::TimeWindow>,
    {
        use std::iter::Iterator;
        self.maintenance_exclusions = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [policy][crate::model::MaintenanceWindow::policy].
    ///
    /// Note that all the setters affecting `policy` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceWindow;
    /// use google_cloud_container_v1::model::DailyMaintenanceWindow;
    /// let x = MaintenanceWindow::new().set_policy(Some(
    ///     google_cloud_container_v1::model::maintenance_window::Policy::DailyMaintenanceWindow(DailyMaintenanceWindow::default().into())));
    /// ```
    pub fn set_policy<
        T: std::convert::Into<std::option::Option<crate::model::maintenance_window::Policy>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy = v.into();
        self
    }

    /// The value of [policy][crate::model::MaintenanceWindow::policy]
    /// if it holds a `DailyMaintenanceWindow`, `None` if the field is not set or
    /// holds a different branch.
    pub fn daily_maintenance_window(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DailyMaintenanceWindow>> {
        #[allow(unreachable_patterns)]
        self.policy.as_ref().and_then(|v| match v {
            crate::model::maintenance_window::Policy::DailyMaintenanceWindow(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy][crate::model::MaintenanceWindow::policy]
    /// to hold a `DailyMaintenanceWindow`.
    ///
    /// Note that all the setters affecting `policy` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceWindow;
    /// use google_cloud_container_v1::model::DailyMaintenanceWindow;
    /// let x = MaintenanceWindow::new().set_daily_maintenance_window(DailyMaintenanceWindow::default()/* use setters */);
    /// assert!(x.daily_maintenance_window().is_some());
    /// assert!(x.recurring_window().is_none());
    /// assert!(x.recurring_maintenance_window().is_none());
    /// ```
    pub fn set_daily_maintenance_window<
        T: std::convert::Into<std::boxed::Box<crate::model::DailyMaintenanceWindow>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy = std::option::Option::Some(
            crate::model::maintenance_window::Policy::DailyMaintenanceWindow(v.into()),
        );
        self
    }

    /// The value of [policy][crate::model::MaintenanceWindow::policy]
    /// if it holds a `RecurringWindow`, `None` if the field is not set or
    /// holds a different branch.
    pub fn recurring_window(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::RecurringTimeWindow>> {
        #[allow(unreachable_patterns)]
        self.policy.as_ref().and_then(|v| match v {
            crate::model::maintenance_window::Policy::RecurringWindow(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy][crate::model::MaintenanceWindow::policy]
    /// to hold a `RecurringWindow`.
    ///
    /// Note that all the setters affecting `policy` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceWindow;
    /// use google_cloud_container_v1::model::RecurringTimeWindow;
    /// let x = MaintenanceWindow::new().set_recurring_window(RecurringTimeWindow::default()/* use setters */);
    /// assert!(x.recurring_window().is_some());
    /// assert!(x.daily_maintenance_window().is_none());
    /// assert!(x.recurring_maintenance_window().is_none());
    /// ```
    pub fn set_recurring_window<
        T: std::convert::Into<std::boxed::Box<crate::model::RecurringTimeWindow>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy = std::option::Option::Some(
            crate::model::maintenance_window::Policy::RecurringWindow(v.into()),
        );
        self
    }

    /// The value of [policy][crate::model::MaintenanceWindow::policy]
    /// if it holds a `RecurringMaintenanceWindow`, `None` if the field is not set or
    /// holds a different branch.
    pub fn recurring_maintenance_window(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::RecurringMaintenanceWindow>> {
        #[allow(unreachable_patterns)]
        self.policy.as_ref().and_then(|v| match v {
            crate::model::maintenance_window::Policy::RecurringMaintenanceWindow(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [policy][crate::model::MaintenanceWindow::policy]
    /// to hold a `RecurringMaintenanceWindow`.
    ///
    /// Note that all the setters affecting `policy` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceWindow;
    /// use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// let x = MaintenanceWindow::new().set_recurring_maintenance_window(RecurringMaintenanceWindow::default()/* use setters */);
    /// assert!(x.recurring_maintenance_window().is_some());
    /// assert!(x.daily_maintenance_window().is_none());
    /// assert!(x.recurring_window().is_none());
    /// ```
    pub fn set_recurring_maintenance_window<
        T: std::convert::Into<std::boxed::Box<crate::model::RecurringMaintenanceWindow>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.policy = std::option::Option::Some(
            crate::model::maintenance_window::Policy::RecurringMaintenanceWindow(v.into()),
        );
        self
    }
}

impl wkt::message::Message for MaintenanceWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MaintenanceWindow"
    }
}

/// Defines additional types related to [MaintenanceWindow].
pub mod maintenance_window {
    #[allow(unused_imports)]
    use super::*;

    #[allow(missing_docs)]
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Policy {
        /// DailyMaintenanceWindow specifies a daily maintenance operation window.
        DailyMaintenanceWindow(std::boxed::Box<crate::model::DailyMaintenanceWindow>),
        /// RecurringWindow specifies some number of recurring time periods for
        /// maintenance to occur. The time windows may be overlapping. If no
        /// maintenance windows are set, maintenance can occur at any time.
        RecurringWindow(std::boxed::Box<crate::model::RecurringTimeWindow>),
        /// RecurringMaintenanceWindow specifies some number of recurring time
        /// periods for maintenance to occur. The time windows may be overlapping.
        /// If no maintenance windows are set, maintenance can occur at any time.
        /// Alternative to RecurringWindow, with renamed fields.
        RecurringMaintenanceWindow(std::boxed::Box<crate::model::RecurringMaintenanceWindow>),
    }
}

/// Represents an arbitrary window of time.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct TimeWindow {
    /// The time that the window first starts.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// The time that the window ends. The end time should take place after the
    /// start time.
    pub end_time: std::option::Option<wkt::Timestamp>,

    #[allow(missing_docs)]
    pub options: std::option::Option<crate::model::time_window::Options>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl TimeWindow {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [start_time][crate::model::TimeWindow::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use wkt::Timestamp;
    /// let x = TimeWindow::new().set_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_time][crate::model::TimeWindow::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use wkt::Timestamp;
    /// let x = TimeWindow::new().set_or_clear_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = TimeWindow::new().set_or_clear_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::TimeWindow::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use wkt::Timestamp;
    /// let x = TimeWindow::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::TimeWindow::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use wkt::Timestamp;
    /// let x = TimeWindow::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = TimeWindow::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [options][crate::model::TimeWindow::options].
    ///
    /// Note that all the setters affecting `options` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use google_cloud_container_v1::model::MaintenanceExclusionOptions;
    /// let x = TimeWindow::new().set_options(Some(
    ///     google_cloud_container_v1::model::time_window::Options::MaintenanceExclusionOptions(MaintenanceExclusionOptions::default().into())));
    /// ```
    pub fn set_options<
        T: std::convert::Into<std::option::Option<crate::model::time_window::Options>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.options = v.into();
        self
    }

    /// The value of [options][crate::model::TimeWindow::options]
    /// if it holds a `MaintenanceExclusionOptions`, `None` if the field is not set or
    /// holds a different branch.
    pub fn maintenance_exclusion_options(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::MaintenanceExclusionOptions>> {
        #[allow(unreachable_patterns)]
        self.options.as_ref().and_then(|v| match v {
            crate::model::time_window::Options::MaintenanceExclusionOptions(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [options][crate::model::TimeWindow::options]
    /// to hold a `MaintenanceExclusionOptions`.
    ///
    /// Note that all the setters affecting `options` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::TimeWindow;
    /// use google_cloud_container_v1::model::MaintenanceExclusionOptions;
    /// let x = TimeWindow::new().set_maintenance_exclusion_options(MaintenanceExclusionOptions::default()/* use setters */);
    /// assert!(x.maintenance_exclusion_options().is_some());
    /// ```
    pub fn set_maintenance_exclusion_options<
        T: std::convert::Into<std::boxed::Box<crate::model::MaintenanceExclusionOptions>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.options = std::option::Option::Some(
            crate::model::time_window::Options::MaintenanceExclusionOptions(v.into()),
        );
        self
    }
}

impl wkt::message::Message for TimeWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.TimeWindow"
    }
}

/// Defines additional types related to [TimeWindow].
pub mod time_window {
    #[allow(unused_imports)]
    use super::*;

    #[allow(missing_docs)]
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Options {
        /// MaintenanceExclusionOptions provides maintenance exclusion related
        /// options.
        MaintenanceExclusionOptions(std::boxed::Box<crate::model::MaintenanceExclusionOptions>),
    }
}

/// Represents the Maintenance exclusion option.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaintenanceExclusionOptions {
    /// Scope specifies the upgrade scope which upgrades are blocked by the
    /// exclusion.
    pub scope: crate::model::maintenance_exclusion_options::Scope,

    /// EndTimeBehavior specifies the behavior of the exclusion end time.
    pub end_time_behavior: crate::model::maintenance_exclusion_options::EndTimeBehavior,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaintenanceExclusionOptions {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [scope][crate::model::MaintenanceExclusionOptions::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceExclusionOptions;
    /// use google_cloud_container_v1::model::maintenance_exclusion_options::Scope;
    /// let x0 = MaintenanceExclusionOptions::new().set_scope(Scope::NoMinorUpgrades);
    /// let x1 = MaintenanceExclusionOptions::new().set_scope(Scope::NoMinorOrNodeUpgrades);
    /// ```
    pub fn set_scope<T: std::convert::Into<crate::model::maintenance_exclusion_options::Scope>>(
        mut self,
        v: T,
    ) -> Self {
        self.scope = v.into();
        self
    }

    /// Sets the value of [end_time_behavior][crate::model::MaintenanceExclusionOptions::end_time_behavior].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaintenanceExclusionOptions;
    /// use google_cloud_container_v1::model::maintenance_exclusion_options::EndTimeBehavior;
    /// let x0 = MaintenanceExclusionOptions::new().set_end_time_behavior(EndTimeBehavior::UntilEndOfSupport);
    /// ```
    pub fn set_end_time_behavior<
        T: std::convert::Into<crate::model::maintenance_exclusion_options::EndTimeBehavior>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.end_time_behavior = v.into();
        self
    }
}

impl wkt::message::Message for MaintenanceExclusionOptions {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MaintenanceExclusionOptions"
    }
}

/// Defines additional types related to [MaintenanceExclusionOptions].
pub mod maintenance_exclusion_options {
    #[allow(unused_imports)]
    use super::*;

    /// Scope of exclusion.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Scope {
        /// NO_UPGRADES excludes all upgrades, including patch upgrades and minor
        /// upgrades across control planes and nodes. This is the default exclusion
        /// behavior.
        NoUpgrades,
        /// NO_MINOR_UPGRADES excludes all minor upgrades for the cluster, only
        /// patches are allowed.
        NoMinorUpgrades,
        /// NO_MINOR_OR_NODE_UPGRADES excludes all minor upgrades for the cluster,
        /// and also exclude all node pool upgrades. Only control
        /// plane patches are allowed.
        NoMinorOrNodeUpgrades,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Scope::value] or
        /// [Scope::name].
        UnknownValue(scope::UnknownValue),
    }

    #[doc(hidden)]
    pub mod scope {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Scope {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::NoUpgrades => std::option::Option::Some(0),
                Self::NoMinorUpgrades => std::option::Option::Some(1),
                Self::NoMinorOrNodeUpgrades => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::NoUpgrades => std::option::Option::Some("NO_UPGRADES"),
                Self::NoMinorUpgrades => std::option::Option::Some("NO_MINOR_UPGRADES"),
                Self::NoMinorOrNodeUpgrades => {
                    std::option::Option::Some("NO_MINOR_OR_NODE_UPGRADES")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Scope {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Scope {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Scope {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::NoUpgrades,
                1 => Self::NoMinorUpgrades,
                2 => Self::NoMinorOrNodeUpgrades,
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Scope {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "NO_UPGRADES" => Self::NoUpgrades,
                "NO_MINOR_UPGRADES" => Self::NoMinorUpgrades,
                "NO_MINOR_OR_NODE_UPGRADES" => Self::NoMinorOrNodeUpgrades,
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Scope {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::NoUpgrades => serializer.serialize_i32(0),
                Self::NoMinorUpgrades => serializer.serialize_i32(1),
                Self::NoMinorOrNodeUpgrades => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Scope {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Scope>::new(
                ".google.container.v1.MaintenanceExclusionOptions.Scope",
            ))
        }
    }

    /// EndTimeBehavior specifies the behavior of the exclusion end time.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EndTimeBehavior {
        /// END_TIME_BEHAVIOR_UNSPECIFIED is the default behavior, which is fixed
        /// end time.
        Unspecified,
        /// UNTIL_END_OF_SUPPORT means the exclusion will be in effect until the end
        /// of the support of the cluster's current version.
        UntilEndOfSupport,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EndTimeBehavior::value] or
        /// [EndTimeBehavior::name].
        UnknownValue(end_time_behavior::UnknownValue),
    }

    #[doc(hidden)]
    pub mod end_time_behavior {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EndTimeBehavior {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::UntilEndOfSupport => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("END_TIME_BEHAVIOR_UNSPECIFIED"),
                Self::UntilEndOfSupport => std::option::Option::Some("UNTIL_END_OF_SUPPORT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EndTimeBehavior {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EndTimeBehavior {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EndTimeBehavior {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::UntilEndOfSupport,
                _ => Self::UnknownValue(end_time_behavior::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EndTimeBehavior {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "END_TIME_BEHAVIOR_UNSPECIFIED" => Self::Unspecified,
                "UNTIL_END_OF_SUPPORT" => Self::UntilEndOfSupport,
                _ => Self::UnknownValue(end_time_behavior::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EndTimeBehavior {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::UntilEndOfSupport => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EndTimeBehavior {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EndTimeBehavior>::new(
                ".google.container.v1.MaintenanceExclusionOptions.EndTimeBehavior",
            ))
        }
    }
}

/// Represents an arbitrary window of time that recurs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RecurringTimeWindow {
    /// The window of the first recurrence.
    pub window: std::option::Option<crate::model::TimeWindow>,

    /// An RRULE (<https://tools.ietf.org/html/rfc5545#section-3.8.5.3>) for how
    /// this window recurs. They go on for the span of time between the start and
    /// end time.
    ///
    /// For example, to have something repeat every weekday, you'd use:
    /// `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR`
    ///
    /// To repeat some window daily (equivalent to the DailyMaintenanceWindow):
    /// `FREQ=DAILY`
    ///
    /// For the first weekend of every month:
    /// `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU`
    ///
    /// This specifies how frequently the window starts. Eg, if you wanted to have
    /// a 9-5 UTC-4 window every weekday, you'd use something like:
    ///
    /// ```norust
    /// start time = 2019-01-01T09:00:00-0400
    /// end time = 2019-01-01T17:00:00-0400
    /// recurrence = FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR
    /// ```
    ///
    /// Windows can span multiple days. Eg, to make the window encompass every
    /// weekend from midnight Saturday till the last minute of Sunday UTC:
    ///
    /// ```norust
    /// start time = 2019-01-05T00:00:00Z
    /// end time = 2019-01-07T23:59:00Z
    /// recurrence = FREQ=WEEKLY;BYDAY=SA
    /// ```
    ///
    /// Note the start and end time's specific dates are largely arbitrary except
    /// to specify duration of the window and when it first starts.
    /// The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
    pub recurrence: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RecurringTimeWindow {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [window][crate::model::RecurringTimeWindow::window].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringTimeWindow;
    /// use google_cloud_container_v1::model::TimeWindow;
    /// let x = RecurringTimeWindow::new().set_window(TimeWindow::default()/* use setters */);
    /// ```
    pub fn set_window<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::TimeWindow>,
    {
        self.window = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [window][crate::model::RecurringTimeWindow::window].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringTimeWindow;
    /// use google_cloud_container_v1::model::TimeWindow;
    /// let x = RecurringTimeWindow::new().set_or_clear_window(Some(TimeWindow::default()/* use setters */));
    /// let x = RecurringTimeWindow::new().set_or_clear_window(None::<TimeWindow>);
    /// ```
    pub fn set_or_clear_window<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::TimeWindow>,
    {
        self.window = v.map(|x| x.into());
        self
    }

    /// Sets the value of [recurrence][crate::model::RecurringTimeWindow::recurrence].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringTimeWindow;
    /// let x = RecurringTimeWindow::new().set_recurrence("example");
    /// ```
    pub fn set_recurrence<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.recurrence = v.into();
        self
    }
}

impl wkt::message::Message for RecurringTimeWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RecurringTimeWindow"
    }
}

/// Represents an arbitrary window of time that recurs.
/// Will replace RecurringTimeWindow.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RecurringMaintenanceWindow {
    /// Optional. Specifies the date before which will not be scheduled.
    /// Depending on the recurrence, this may be the date the first window appears.
    /// Days are measured in the UTC timezone. This setting must be used when
    /// INTERVAL>1 or FREQ=WEEKLY/MONTHLY and no BYDAY specified.
    pub delay_until: std::option::Option<google_cloud_type::model::Date>,

    /// Required. Start time of the window on days that it is scheduled,
    /// assuming UTC timezone.
    pub window_start_time: std::option::Option<google_cloud_type::model::TimeOfDay>,

    /// Required. Duration of the window.
    pub window_duration: std::option::Option<wkt::Duration>,

    /// Required. An RRULE (<https://tools.ietf.org/html/rfc5545#section-3.8.5.3>)
    /// for how this window recurs.
    ///
    /// For example, to have something repeat every weekday, you'd use:
    /// `FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR`
    ///
    /// To repeat some window daily (equivalent to the DailyMaintenanceWindow):
    /// `FREQ=DAILY`
    ///
    /// For the first weekend of every month:
    /// `FREQ=MONTHLY;BYSETPOS=1;BYDAY=SA,SU`
    ///
    /// The FREQ values of HOURLY, MINUTELY, and SECONDLY are not supported.
    pub recurrence: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RecurringMaintenanceWindow {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [delay_until][crate::model::RecurringMaintenanceWindow::delay_until].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use google_cloud_type::model::Date;
    /// let x = RecurringMaintenanceWindow::new().set_delay_until(Date::default()/* use setters */);
    /// ```
    pub fn set_delay_until<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.delay_until = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [delay_until][crate::model::RecurringMaintenanceWindow::delay_until].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use google_cloud_type::model::Date;
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_delay_until(Some(Date::default()/* use setters */));
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_delay_until(None::<Date>);
    /// ```
    pub fn set_or_clear_delay_until<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::Date>,
    {
        self.delay_until = v.map(|x| x.into());
        self
    }

    /// Sets the value of [window_start_time][crate::model::RecurringMaintenanceWindow::window_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use google_cloud_type::model::TimeOfDay;
    /// let x = RecurringMaintenanceWindow::new().set_window_start_time(TimeOfDay::default()/* use setters */);
    /// ```
    pub fn set_window_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::TimeOfDay>,
    {
        self.window_start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [window_start_time][crate::model::RecurringMaintenanceWindow::window_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use google_cloud_type::model::TimeOfDay;
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_window_start_time(Some(TimeOfDay::default()/* use setters */));
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_window_start_time(None::<TimeOfDay>);
    /// ```
    pub fn set_or_clear_window_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<google_cloud_type::model::TimeOfDay>,
    {
        self.window_start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [window_duration][crate::model::RecurringMaintenanceWindow::window_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use wkt::Duration;
    /// let x = RecurringMaintenanceWindow::new().set_window_duration(Duration::default()/* use setters */);
    /// ```
    pub fn set_window_duration<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.window_duration = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [window_duration][crate::model::RecurringMaintenanceWindow::window_duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// use wkt::Duration;
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_window_duration(Some(Duration::default()/* use setters */));
    /// let x = RecurringMaintenanceWindow::new().set_or_clear_window_duration(None::<Duration>);
    /// ```
    pub fn set_or_clear_window_duration<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.window_duration = v.map(|x| x.into());
        self
    }

    /// Sets the value of [recurrence][crate::model::RecurringMaintenanceWindow::recurrence].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RecurringMaintenanceWindow;
    /// let x = RecurringMaintenanceWindow::new().set_recurrence("example");
    /// ```
    pub fn set_recurrence<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.recurrence = v.into();
        self
    }
}

impl wkt::message::Message for RecurringMaintenanceWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RecurringMaintenanceWindow"
    }
}

/// Time window specified for daily maintenance operations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DailyMaintenanceWindow {
    /// Time within the maintenance window to start the maintenance operations.
    /// Time format should be in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt)
    /// format "HH:MM", where HH : [00-23] and MM : [00-59] GMT.
    pub start_time: std::string::String,

    /// Output only. Duration of the time window, automatically chosen to be
    /// smallest possible in the given scenario.
    /// Duration will be in [RFC3339](https://www.ietf.org/rfc/rfc3339.txt)
    /// format "PTnHnMnS".
    pub duration: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DailyMaintenanceWindow {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [start_time][crate::model::DailyMaintenanceWindow::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DailyMaintenanceWindow;
    /// let x = DailyMaintenanceWindow::new().set_start_time("example");
    /// ```
    pub fn set_start_time<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.start_time = v.into();
        self
    }

    /// Sets the value of [duration][crate::model::DailyMaintenanceWindow::duration].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DailyMaintenanceWindow;
    /// let x = DailyMaintenanceWindow::new().set_duration("example");
    /// ```
    pub fn set_duration<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.duration = v.into();
        self
    }
}

impl wkt::message::Message for DailyMaintenanceWindow {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DailyMaintenanceWindow"
    }
}

/// SetNodePoolManagementRequest sets the node management properties of a node
/// pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetNodePoolManagementRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to update.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to update.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// Required. NodeManagement configuration for the node pool.
    pub management: std::option::Option<crate::model::NodeManagement>,

    /// The name (project, location, cluster, node pool id) of the node pool to set
    /// management properties. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetNodePoolManagementRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetNodePoolManagementRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// let x = SetNodePoolManagementRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetNodePoolManagementRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// let x = SetNodePoolManagementRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetNodePoolManagementRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// let x = SetNodePoolManagementRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::SetNodePoolManagementRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// let x = SetNodePoolManagementRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [management][crate::model::SetNodePoolManagementRequest::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = SetNodePoolManagementRequest::new().set_management(NodeManagement::default()/* use setters */);
    /// ```
    pub fn set_management<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [management][crate::model::SetNodePoolManagementRequest::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = SetNodePoolManagementRequest::new().set_or_clear_management(Some(NodeManagement::default()/* use setters */));
    /// let x = SetNodePoolManagementRequest::new().set_or_clear_management(None::<NodeManagement>);
    /// ```
    pub fn set_or_clear_management<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetNodePoolManagementRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolManagementRequest;
    /// let x = SetNodePoolManagementRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetNodePoolManagementRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetNodePoolManagementRequest"
    }
}

/// SetNodePoolSizeRequest sets the size of a node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetNodePoolSizeRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to update.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to update.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// Required. The desired node count for the pool.
    pub node_count: i32,

    /// The name (project, location, cluster, node pool id) of the node pool to set
    /// size.
    /// Specified in the format `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetNodePoolSizeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetNodePoolSizeRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetNodePoolSizeRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetNodePoolSizeRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::SetNodePoolSizeRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [node_count][crate::model::SetNodePoolSizeRequest::node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_node_count(42);
    /// ```
    pub fn set_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.node_count = v.into();
        self
    }

    /// Sets the value of [name][crate::model::SetNodePoolSizeRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNodePoolSizeRequest;
    /// let x = SetNodePoolSizeRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetNodePoolSizeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetNodePoolSizeRequest"
    }
}

/// CompleteNodePoolUpgradeRequest sets the name of target node pool to complete
/// upgrade.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CompleteNodePoolUpgradeRequest {
    /// The name (project, location, cluster, node pool id) of the node pool to
    /// complete upgrade.
    /// Specified in the format `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CompleteNodePoolUpgradeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::CompleteNodePoolUpgradeRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompleteNodePoolUpgradeRequest;
    /// let x = CompleteNodePoolUpgradeRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for CompleteNodePoolUpgradeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CompleteNodePoolUpgradeRequest"
    }
}

/// RollbackNodePoolUpgradeRequest rollbacks the previously Aborted or Failed
/// NodePool upgrade. This will be an no-op if the last upgrade successfully
/// completed.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RollbackNodePoolUpgradeRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to rollback.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Deprecated. The name of the node pool to rollback.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub node_pool_id: std::string::String,

    /// The name (project, location, cluster, node pool id) of the node poll to
    /// rollback upgrade.
    /// Specified in the format `projects/*/locations/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    /// Option for rollback to ignore the PodDisruptionBudget.
    /// Default value is false.
    pub respect_pdb: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RollbackNodePoolUpgradeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::RollbackNodePoolUpgradeRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::RollbackNodePoolUpgradeRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::RollbackNodePoolUpgradeRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [node_pool_id][crate::model::RollbackNodePoolUpgradeRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_node_pool_id("example");
    /// ```
    #[deprecated]
    pub fn set_node_pool_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.node_pool_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::RollbackNodePoolUpgradeRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [respect_pdb][crate::model::RollbackNodePoolUpgradeRequest::respect_pdb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RollbackNodePoolUpgradeRequest;
    /// let x = RollbackNodePoolUpgradeRequest::new().set_respect_pdb(true);
    /// ```
    pub fn set_respect_pdb<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.respect_pdb = v.into();
        self
    }
}

impl wkt::message::Message for RollbackNodePoolUpgradeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RollbackNodePoolUpgradeRequest"
    }
}

/// ListNodePoolsResponse is the result of ListNodePoolsRequest.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListNodePoolsResponse {
    /// A list of node pools for a cluster.
    pub node_pools: std::vec::Vec<crate::model::NodePool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListNodePoolsResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [node_pools][crate::model::ListNodePoolsResponse::node_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListNodePoolsResponse;
    /// use google_cloud_container_v1::model::NodePool;
    /// let x = ListNodePoolsResponse::new()
    ///     .set_node_pools([
    ///         NodePool::default()/* use setters */,
    ///         NodePool::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_node_pools<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::NodePool>,
    {
        use std::iter::Iterator;
        self.node_pools = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListNodePoolsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListNodePoolsResponse"
    }
}

/// ClusterAutoscaling contains global, per-cluster information
/// required by Cluster Autoscaler to automatically adjust
/// the size of the cluster and create/delete
/// node pools based on the current needs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClusterAutoscaling {
    /// Enables automatic node pool creation and deletion.
    pub enable_node_autoprovisioning: bool,

    /// Contains global constraints regarding minimum and maximum
    /// amount of resources in the cluster.
    pub resource_limits: std::vec::Vec<crate::model::ResourceLimit>,

    /// Defines autoscaling behaviour.
    pub autoscaling_profile: crate::model::cluster_autoscaling::AutoscalingProfile,

    /// AutoprovisioningNodePoolDefaults contains defaults for a node pool
    /// created by NAP.
    pub autoprovisioning_node_pool_defaults:
        std::option::Option<crate::model::AutoprovisioningNodePoolDefaults>,

    /// The list of Google Compute Engine
    /// [zones](https://cloud.google.com/compute/docs/zones#available)
    /// in which the NodePool's nodes can be created by NAP.
    pub autoprovisioning_locations: std::vec::Vec<std::string::String>,

    /// Default compute class is a configuration for default compute class.
    pub default_compute_class_config: std::option::Option<crate::model::DefaultComputeClassConfig>,

    /// Autopilot general profile for the cluster, which defines the
    /// configuration for the cluster.
    pub autopilot_general_profile: crate::model::cluster_autoscaling::AutopilotGeneralProfile,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ClusterAutoscaling {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_node_autoprovisioning][crate::model::ClusterAutoscaling::enable_node_autoprovisioning].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = ClusterAutoscaling::new().set_enable_node_autoprovisioning(true);
    /// ```
    pub fn set_enable_node_autoprovisioning<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_node_autoprovisioning = v.into();
        self
    }

    /// Sets the value of [resource_limits][crate::model::ClusterAutoscaling::resource_limits].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::ResourceLimit;
    /// let x = ClusterAutoscaling::new()
    ///     .set_resource_limits([
    ///         ResourceLimit::default()/* use setters */,
    ///         ResourceLimit::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_resource_limits<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::ResourceLimit>,
    {
        use std::iter::Iterator;
        self.resource_limits = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [autoscaling_profile][crate::model::ClusterAutoscaling::autoscaling_profile].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::cluster_autoscaling::AutoscalingProfile;
    /// let x0 = ClusterAutoscaling::new().set_autoscaling_profile(AutoscalingProfile::OptimizeUtilization);
    /// let x1 = ClusterAutoscaling::new().set_autoscaling_profile(AutoscalingProfile::Balanced);
    /// ```
    pub fn set_autoscaling_profile<
        T: std::convert::Into<crate::model::cluster_autoscaling::AutoscalingProfile>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.autoscaling_profile = v.into();
        self
    }

    /// Sets the value of [autoprovisioning_node_pool_defaults][crate::model::ClusterAutoscaling::autoprovisioning_node_pool_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = ClusterAutoscaling::new().set_autoprovisioning_node_pool_defaults(AutoprovisioningNodePoolDefaults::default()/* use setters */);
    /// ```
    pub fn set_autoprovisioning_node_pool_defaults<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AutoprovisioningNodePoolDefaults>,
    {
        self.autoprovisioning_node_pool_defaults = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autoprovisioning_node_pool_defaults][crate::model::ClusterAutoscaling::autoprovisioning_node_pool_defaults].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = ClusterAutoscaling::new().set_or_clear_autoprovisioning_node_pool_defaults(Some(AutoprovisioningNodePoolDefaults::default()/* use setters */));
    /// let x = ClusterAutoscaling::new().set_or_clear_autoprovisioning_node_pool_defaults(None::<AutoprovisioningNodePoolDefaults>);
    /// ```
    pub fn set_or_clear_autoprovisioning_node_pool_defaults<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AutoprovisioningNodePoolDefaults>,
    {
        self.autoprovisioning_node_pool_defaults = v.map(|x| x.into());
        self
    }

    /// Sets the value of [autoprovisioning_locations][crate::model::ClusterAutoscaling::autoprovisioning_locations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// let x = ClusterAutoscaling::new().set_autoprovisioning_locations(["a", "b", "c"]);
    /// ```
    pub fn set_autoprovisioning_locations<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.autoprovisioning_locations = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [default_compute_class_config][crate::model::ClusterAutoscaling::default_compute_class_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::DefaultComputeClassConfig;
    /// let x = ClusterAutoscaling::new().set_default_compute_class_config(DefaultComputeClassConfig::default()/* use setters */);
    /// ```
    pub fn set_default_compute_class_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DefaultComputeClassConfig>,
    {
        self.default_compute_class_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [default_compute_class_config][crate::model::ClusterAutoscaling::default_compute_class_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::DefaultComputeClassConfig;
    /// let x = ClusterAutoscaling::new().set_or_clear_default_compute_class_config(Some(DefaultComputeClassConfig::default()/* use setters */));
    /// let x = ClusterAutoscaling::new().set_or_clear_default_compute_class_config(None::<DefaultComputeClassConfig>);
    /// ```
    pub fn set_or_clear_default_compute_class_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DefaultComputeClassConfig>,
    {
        self.default_compute_class_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [autopilot_general_profile][crate::model::ClusterAutoscaling::autopilot_general_profile].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterAutoscaling;
    /// use google_cloud_container_v1::model::cluster_autoscaling::AutopilotGeneralProfile;
    /// let x0 = ClusterAutoscaling::new().set_autopilot_general_profile(AutopilotGeneralProfile::NoPerformance);
    /// let x1 = ClusterAutoscaling::new().set_autopilot_general_profile(AutopilotGeneralProfile::None);
    /// ```
    pub fn set_autopilot_general_profile<
        T: std::convert::Into<crate::model::cluster_autoscaling::AutopilotGeneralProfile>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.autopilot_general_profile = v.into();
        self
    }
}

impl wkt::message::Message for ClusterAutoscaling {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ClusterAutoscaling"
    }
}

/// Defines additional types related to [ClusterAutoscaling].
pub mod cluster_autoscaling {
    #[allow(unused_imports)]
    use super::*;

    /// Defines possible options for autoscaling_profile field.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutoscalingProfile {
        /// No change to autoscaling configuration.
        ProfileUnspecified,
        /// Prioritize optimizing utilization of resources.
        OptimizeUtilization,
        /// Use default (balanced) autoscaling configuration.
        Balanced,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutoscalingProfile::value] or
        /// [AutoscalingProfile::name].
        UnknownValue(autoscaling_profile::UnknownValue),
    }

    #[doc(hidden)]
    pub mod autoscaling_profile {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutoscalingProfile {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::ProfileUnspecified => std::option::Option::Some(0),
                Self::OptimizeUtilization => std::option::Option::Some(1),
                Self::Balanced => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::ProfileUnspecified => std::option::Option::Some("PROFILE_UNSPECIFIED"),
                Self::OptimizeUtilization => std::option::Option::Some("OPTIMIZE_UTILIZATION"),
                Self::Balanced => std::option::Option::Some("BALANCED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutoscalingProfile {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutoscalingProfile {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutoscalingProfile {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::ProfileUnspecified,
                1 => Self::OptimizeUtilization,
                2 => Self::Balanced,
                _ => Self::UnknownValue(autoscaling_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutoscalingProfile {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PROFILE_UNSPECIFIED" => Self::ProfileUnspecified,
                "OPTIMIZE_UTILIZATION" => Self::OptimizeUtilization,
                "BALANCED" => Self::Balanced,
                _ => Self::UnknownValue(autoscaling_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutoscalingProfile {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::ProfileUnspecified => serializer.serialize_i32(0),
                Self::OptimizeUtilization => serializer.serialize_i32(1),
                Self::Balanced => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutoscalingProfile {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<AutoscalingProfile>::new(
                ".google.container.v1.ClusterAutoscaling.AutoscalingProfile",
            ))
        }
    }

    /// Defines possible options for Autopilot general profile.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutopilotGeneralProfile {
        /// Use default configuration.
        Unspecified,
        /// Avoid extra IP consumption.
        NoPerformance,
        /// Use default configuration.
        None,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutopilotGeneralProfile::value] or
        /// [AutopilotGeneralProfile::name].
        UnknownValue(autopilot_general_profile::UnknownValue),
    }

    #[doc(hidden)]
    pub mod autopilot_general_profile {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutopilotGeneralProfile {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::NoPerformance => std::option::Option::Some(1),
                Self::None => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("AUTOPILOT_GENERAL_PROFILE_UNSPECIFIED")
                }
                Self::NoPerformance => std::option::Option::Some("NO_PERFORMANCE"),
                Self::None => std::option::Option::Some("NONE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutopilotGeneralProfile {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutopilotGeneralProfile {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutopilotGeneralProfile {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::NoPerformance,
                2 => Self::None,
                _ => Self::UnknownValue(autopilot_general_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutopilotGeneralProfile {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "AUTOPILOT_GENERAL_PROFILE_UNSPECIFIED" => Self::Unspecified,
                "NO_PERFORMANCE" => Self::NoPerformance,
                "NONE" => Self::None,
                _ => Self::UnknownValue(autopilot_general_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutopilotGeneralProfile {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::NoPerformance => serializer.serialize_i32(1),
                Self::None => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutopilotGeneralProfile {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<AutopilotGeneralProfile>::new(
                    ".google.container.v1.ClusterAutoscaling.AutopilotGeneralProfile",
                ),
            )
        }
    }
}

/// AutoprovisioningNodePoolDefaults contains defaults for a node pool created
/// by NAP.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AutoprovisioningNodePoolDefaults {
    /// Scopes that are used by NAP when creating node pools.
    pub oauth_scopes: std::vec::Vec<std::string::String>,

    /// The Google Cloud Platform Service Account to be used by the node VMs.
    pub service_account: std::string::String,

    /// Specifies the upgrade settings for NAP created node pools
    pub upgrade_settings: std::option::Option<crate::model::node_pool::UpgradeSettings>,

    /// Specifies the node management options for NAP created node-pools.
    pub management: std::option::Option<crate::model::NodeManagement>,

    /// Deprecated. Minimum CPU platform to be used for NAP created node pools.
    /// The instance may be scheduled on the specified or newer CPU platform.
    /// Applicable values are the friendly names of CPU platforms, such as
    /// minCpuPlatform: Intel Haswell or
    /// minCpuPlatform: Intel Sandy Bridge. For more
    /// information, read [how to specify min CPU
    /// platform](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform).
    /// This field is deprecated, min_cpu_platform should be specified using
    /// `cloud.google.com/requested-min-cpu-platform` label selector on the pod.
    /// To unset the min cpu platform field pass "automatic"
    /// as field value.
    #[deprecated]
    pub min_cpu_platform: std::string::String,

    /// Size of the disk attached to each node, specified in GB.
    /// The smallest allowed disk size is 10GB.
    ///
    /// If unspecified, the default disk size is 100GB.
    pub disk_size_gb: i32,

    /// Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or
    /// 'pd-balanced')
    ///
    /// If unspecified, the default disk type is 'pd-standard'
    pub disk_type: std::string::String,

    /// Shielded Instance options.
    pub shielded_instance_config: std::option::Option<crate::model::ShieldedInstanceConfig>,

    /// The Customer Managed Encryption Key used to encrypt the boot disk attached
    /// to each node in the node pool. This should be of the form
    /// projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME].
    /// For more information about protecting resources with Cloud KMS Keys please
    /// see:
    /// <https://cloud.google.com/compute/docs/disks/customer-managed-encryption>
    pub boot_disk_kms_key: std::string::String,

    /// The image type to use for NAP created node. Please see
    /// <https://cloud.google.com/kubernetes-engine/docs/concepts/node-images>
    /// for available image types.
    pub image_type: std::string::String,

    /// DEPRECATED. Use NodePoolAutoConfig.NodeKubeletConfig instead.
    pub insecure_kubelet_readonly_port_enabled: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AutoprovisioningNodePoolDefaults {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [oauth_scopes][crate::model::AutoprovisioningNodePoolDefaults::oauth_scopes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_oauth_scopes(["a", "b", "c"]);
    /// ```
    pub fn set_oauth_scopes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.oauth_scopes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service_account][crate::model::AutoprovisioningNodePoolDefaults::service_account].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_service_account("example");
    /// ```
    pub fn set_service_account<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.service_account = v.into();
        self
    }

    /// Sets the value of [upgrade_settings][crate::model::AutoprovisioningNodePoolDefaults::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_upgrade_settings(UpgradeSettings::default()/* use setters */);
    /// ```
    pub fn set_upgrade_settings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [upgrade_settings][crate::model::AutoprovisioningNodePoolDefaults::upgrade_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::node_pool::UpgradeSettings;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_upgrade_settings(Some(UpgradeSettings::default()/* use setters */));
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_upgrade_settings(None::<UpgradeSettings>);
    /// ```
    pub fn set_or_clear_upgrade_settings<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::node_pool::UpgradeSettings>,
    {
        self.upgrade_settings = v.map(|x| x.into());
        self
    }

    /// Sets the value of [management][crate::model::AutoprovisioningNodePoolDefaults::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_management(NodeManagement::default()/* use setters */);
    /// ```
    pub fn set_management<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [management][crate::model::AutoprovisioningNodePoolDefaults::management].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::NodeManagement;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_management(Some(NodeManagement::default()/* use setters */));
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_management(None::<NodeManagement>);
    /// ```
    pub fn set_or_clear_management<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NodeManagement>,
    {
        self.management = v.map(|x| x.into());
        self
    }

    /// Sets the value of [min_cpu_platform][crate::model::AutoprovisioningNodePoolDefaults::min_cpu_platform].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_min_cpu_platform("example");
    /// ```
    #[deprecated]
    pub fn set_min_cpu_platform<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.min_cpu_platform = v.into();
        self
    }

    /// Sets the value of [disk_size_gb][crate::model::AutoprovisioningNodePoolDefaults::disk_size_gb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_disk_size_gb(42);
    /// ```
    pub fn set_disk_size_gb<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.disk_size_gb = v.into();
        self
    }

    /// Sets the value of [disk_type][crate::model::AutoprovisioningNodePoolDefaults::disk_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_disk_type("example");
    /// ```
    pub fn set_disk_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.disk_type = v.into();
        self
    }

    /// Sets the value of [shielded_instance_config][crate::model::AutoprovisioningNodePoolDefaults::shielded_instance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_shielded_instance_config(ShieldedInstanceConfig::default()/* use setters */);
    /// ```
    pub fn set_shielded_instance_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedInstanceConfig>,
    {
        self.shielded_instance_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [shielded_instance_config][crate::model::AutoprovisioningNodePoolDefaults::shielded_instance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// use google_cloud_container_v1::model::ShieldedInstanceConfig;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_shielded_instance_config(Some(ShieldedInstanceConfig::default()/* use setters */));
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_shielded_instance_config(None::<ShieldedInstanceConfig>);
    /// ```
    pub fn set_or_clear_shielded_instance_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ShieldedInstanceConfig>,
    {
        self.shielded_instance_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [boot_disk_kms_key][crate::model::AutoprovisioningNodePoolDefaults::boot_disk_kms_key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_boot_disk_kms_key("example");
    /// ```
    pub fn set_boot_disk_kms_key<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.boot_disk_kms_key = v.into();
        self
    }

    /// Sets the value of [image_type][crate::model::AutoprovisioningNodePoolDefaults::image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_image_type("example");
    /// ```
    pub fn set_image_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.image_type = v.into();
        self
    }

    /// Sets the value of [insecure_kubelet_readonly_port_enabled][crate::model::AutoprovisioningNodePoolDefaults::insecure_kubelet_readonly_port_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_insecure_kubelet_readonly_port_enabled(true);
    /// ```
    pub fn set_insecure_kubelet_readonly_port_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.insecure_kubelet_readonly_port_enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [insecure_kubelet_readonly_port_enabled][crate::model::AutoprovisioningNodePoolDefaults::insecure_kubelet_readonly_port_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoprovisioningNodePoolDefaults;
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_insecure_kubelet_readonly_port_enabled(Some(false));
    /// let x = AutoprovisioningNodePoolDefaults::new().set_or_clear_insecure_kubelet_readonly_port_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_insecure_kubelet_readonly_port_enabled<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.insecure_kubelet_readonly_port_enabled = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AutoprovisioningNodePoolDefaults {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AutoprovisioningNodePoolDefaults"
    }
}

/// Contains information about amount of some resource in the cluster.
/// For memory, value should be in GB.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResourceLimit {
    /// Resource name "cpu", "memory" or gpu-specific string.
    pub resource_type: std::string::String,

    /// Minimum amount of the resource in the cluster.
    pub minimum: i64,

    /// Maximum amount of the resource in the cluster.
    pub maximum: i64,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ResourceLimit {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource_type][crate::model::ResourceLimit::resource_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceLimit;
    /// let x = ResourceLimit::new().set_resource_type("example");
    /// ```
    pub fn set_resource_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource_type = v.into();
        self
    }

    /// Sets the value of [minimum][crate::model::ResourceLimit::minimum].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceLimit;
    /// let x = ResourceLimit::new().set_minimum(42);
    /// ```
    pub fn set_minimum<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.minimum = v.into();
        self
    }

    /// Sets the value of [maximum][crate::model::ResourceLimit::maximum].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceLimit;
    /// let x = ResourceLimit::new().set_maximum(42);
    /// ```
    pub fn set_maximum<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.maximum = v.into();
        self
    }
}

impl wkt::message::Message for ResourceLimit {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ResourceLimit"
    }
}

/// DefaultComputeClassConfig defines default compute class
/// configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DefaultComputeClassConfig {
    /// Enables default compute class.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DefaultComputeClassConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::DefaultComputeClassConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DefaultComputeClassConfig;
    /// let x = DefaultComputeClassConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for DefaultComputeClassConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DefaultComputeClassConfig"
    }
}

/// NodePoolAutoscaling contains information required by cluster autoscaler to
/// adjust the size of the node pool to the current cluster usage.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePoolAutoscaling {
    /// Is autoscaling enabled for this node pool.
    pub enabled: bool,

    /// Minimum number of nodes for one location in the node pool. Must be greater
    /// than or equal to 0 and less than or equal to max_node_count.
    pub min_node_count: i32,

    /// Maximum number of nodes for one location in the node pool. Must be >=
    /// min_node_count. There has to be enough quota to scale up the cluster.
    pub max_node_count: i32,

    /// Can this node pool be deleted automatically.
    pub autoprovisioned: bool,

    /// Location policy used when scaling up a node pool.
    pub location_policy: crate::model::node_pool_autoscaling::LocationPolicy,

    /// Minimum number of nodes in the node pool. Must be greater than or equal
    /// to 0 and less than or equal to total_max_node_count.
    /// The total_*_node_count fields are mutually exclusive with the *_node_count
    /// fields.
    pub total_min_node_count: i32,

    /// Maximum number of nodes in the node pool. Must be greater than or equal to
    /// total_min_node_count. There has to be enough quota to scale up the cluster.
    /// The total_*_node_count fields are mutually exclusive with the *_node_count
    /// fields.
    pub total_max_node_count: i32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePoolAutoscaling {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::NodePoolAutoscaling::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [min_node_count][crate::model::NodePoolAutoscaling::min_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_min_node_count(42);
    /// ```
    pub fn set_min_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.min_node_count = v.into();
        self
    }

    /// Sets the value of [max_node_count][crate::model::NodePoolAutoscaling::max_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_max_node_count(42);
    /// ```
    pub fn set_max_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.max_node_count = v.into();
        self
    }

    /// Sets the value of [autoprovisioned][crate::model::NodePoolAutoscaling::autoprovisioned].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_autoprovisioned(true);
    /// ```
    pub fn set_autoprovisioned<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.autoprovisioned = v.into();
        self
    }

    /// Sets the value of [location_policy][crate::model::NodePoolAutoscaling::location_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// use google_cloud_container_v1::model::node_pool_autoscaling::LocationPolicy;
    /// let x0 = NodePoolAutoscaling::new().set_location_policy(LocationPolicy::Balanced);
    /// let x1 = NodePoolAutoscaling::new().set_location_policy(LocationPolicy::Any);
    /// ```
    pub fn set_location_policy<
        T: std::convert::Into<crate::model::node_pool_autoscaling::LocationPolicy>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.location_policy = v.into();
        self
    }

    /// Sets the value of [total_min_node_count][crate::model::NodePoolAutoscaling::total_min_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_total_min_node_count(42);
    /// ```
    pub fn set_total_min_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.total_min_node_count = v.into();
        self
    }

    /// Sets the value of [total_max_node_count][crate::model::NodePoolAutoscaling::total_max_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolAutoscaling;
    /// let x = NodePoolAutoscaling::new().set_total_max_node_count(42);
    /// ```
    pub fn set_total_max_node_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.total_max_node_count = v.into();
        self
    }
}

impl wkt::message::Message for NodePoolAutoscaling {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePoolAutoscaling"
    }
}

/// Defines additional types related to [NodePoolAutoscaling].
pub mod node_pool_autoscaling {
    #[allow(unused_imports)]
    use super::*;

    /// Location policy specifies how zones are picked when scaling up the
    /// node pool.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum LocationPolicy {
        /// Not set.
        Unspecified,
        /// BALANCED is a best effort policy that aims to balance the sizes of
        /// different zones.
        Balanced,
        /// ANY policy picks zones that have the highest capacity available.
        Any,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [LocationPolicy::value] or
        /// [LocationPolicy::name].
        UnknownValue(location_policy::UnknownValue),
    }

    #[doc(hidden)]
    pub mod location_policy {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl LocationPolicy {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Balanced => std::option::Option::Some(1),
                Self::Any => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("LOCATION_POLICY_UNSPECIFIED"),
                Self::Balanced => std::option::Option::Some("BALANCED"),
                Self::Any => std::option::Option::Some("ANY"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for LocationPolicy {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for LocationPolicy {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for LocationPolicy {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Balanced,
                2 => Self::Any,
                _ => Self::UnknownValue(location_policy::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for LocationPolicy {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "LOCATION_POLICY_UNSPECIFIED" => Self::Unspecified,
                "BALANCED" => Self::Balanced,
                "ANY" => Self::Any,
                _ => Self::UnknownValue(location_policy::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for LocationPolicy {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Balanced => serializer.serialize_i32(1),
                Self::Any => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for LocationPolicy {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<LocationPolicy>::new(
                ".google.container.v1.NodePoolAutoscaling.LocationPolicy",
            ))
        }
    }
}

/// SetLabelsRequest sets the Google Cloud Platform labels on a Google Container
/// Engine cluster, which will in turn set them for Google Compute Engine
/// resources used by that cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetLabelsRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. The labels to set for that cluster.
    pub resource_labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. The fingerprint of the previous set of labels for this resource,
    /// used to detect conflicts. The fingerprint is initially generated by
    /// Kubernetes Engine and changes after every request to modify or update
    /// labels. You must always provide an up-to-date fingerprint hash when
    /// updating or changing labels. Make a `get()` request to the
    /// resource to get the latest fingerprint.
    pub label_fingerprint: std::string::String,

    /// The name (project, location, cluster name) of the cluster to set labels.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetLabelsRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetLabelsRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetLabelsRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetLabelsRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [resource_labels][crate::model::SetLabelsRequest::resource_labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_resource_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_resource_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.resource_labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [label_fingerprint][crate::model::SetLabelsRequest::label_fingerprint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_label_fingerprint("example");
    /// ```
    pub fn set_label_fingerprint<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.label_fingerprint = v.into();
        self
    }

    /// Sets the value of [name][crate::model::SetLabelsRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLabelsRequest;
    /// let x = SetLabelsRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetLabelsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetLabelsRequest"
    }
}

/// SetLegacyAbacRequest enables or disables the ABAC authorization mechanism for
/// a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetLegacyAbacRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster to update.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. Whether ABAC authorization will be enabled in the cluster.
    pub enabled: bool,

    /// The name (project, location, cluster name) of the cluster to set legacy
    /// abac. Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetLegacyAbacRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetLegacyAbacRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLegacyAbacRequest;
    /// let x = SetLegacyAbacRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetLegacyAbacRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLegacyAbacRequest;
    /// let x = SetLegacyAbacRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetLegacyAbacRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLegacyAbacRequest;
    /// let x = SetLegacyAbacRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [enabled][crate::model::SetLegacyAbacRequest::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLegacyAbacRequest;
    /// let x = SetLegacyAbacRequest::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [name][crate::model::SetLegacyAbacRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetLegacyAbacRequest;
    /// let x = SetLegacyAbacRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetLegacyAbacRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetLegacyAbacRequest"
    }
}

/// StartIPRotationRequest creates a new IP for the cluster and then performs
/// a node upgrade on each node pool to point to the new IP.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StartIPRotationRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// The name (project, location, cluster name) of the cluster to start IP
    /// rotation. Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    /// Whether to rotate credentials during IP rotation.
    pub rotate_credentials: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl StartIPRotationRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::StartIPRotationRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StartIPRotationRequest;
    /// let x = StartIPRotationRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::StartIPRotationRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StartIPRotationRequest;
    /// let x = StartIPRotationRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::StartIPRotationRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StartIPRotationRequest;
    /// let x = StartIPRotationRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::StartIPRotationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StartIPRotationRequest;
    /// let x = StartIPRotationRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [rotate_credentials][crate::model::StartIPRotationRequest::rotate_credentials].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StartIPRotationRequest;
    /// let x = StartIPRotationRequest::new().set_rotate_credentials(true);
    /// ```
    pub fn set_rotate_credentials<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.rotate_credentials = v.into();
        self
    }
}

impl wkt::message::Message for StartIPRotationRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.StartIPRotationRequest"
    }
}

/// CompleteIPRotationRequest moves the cluster master back into single-IP mode.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CompleteIPRotationRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// The name (project, location, cluster name) of the cluster to complete IP
    /// rotation. Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CompleteIPRotationRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::CompleteIPRotationRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompleteIPRotationRequest;
    /// let x = CompleteIPRotationRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::CompleteIPRotationRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompleteIPRotationRequest;
    /// let x = CompleteIPRotationRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::CompleteIPRotationRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompleteIPRotationRequest;
    /// let x = CompleteIPRotationRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [name][crate::model::CompleteIPRotationRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CompleteIPRotationRequest;
    /// let x = CompleteIPRotationRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for CompleteIPRotationRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CompleteIPRotationRequest"
    }
}

/// AcceleratorConfig represents a Hardware Accelerator request.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AcceleratorConfig {
    /// The number of the accelerator cards exposed to an instance.
    pub accelerator_count: i64,

    /// The accelerator type resource name. List of supported accelerators
    /// [here](https://cloud.google.com/compute/docs/gpus)
    pub accelerator_type: std::string::String,

    /// Size of partitions to create on the GPU. Valid values are described in the
    /// NVIDIA [mig user
    /// guide](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/#partitioning).
    pub gpu_partition_size: std::string::String,

    /// The configuration for GPU sharing options.
    pub gpu_sharing_config: std::option::Option<crate::model::GPUSharingConfig>,

    /// The configuration for auto installation of GPU driver.
    pub gpu_driver_installation_config:
        std::option::Option<crate::model::GPUDriverInstallationConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AcceleratorConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [accelerator_count][crate::model::AcceleratorConfig::accelerator_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// let x = AcceleratorConfig::new().set_accelerator_count(42);
    /// ```
    pub fn set_accelerator_count<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.accelerator_count = v.into();
        self
    }

    /// Sets the value of [accelerator_type][crate::model::AcceleratorConfig::accelerator_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// let x = AcceleratorConfig::new().set_accelerator_type("example");
    /// ```
    pub fn set_accelerator_type<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.accelerator_type = v.into();
        self
    }

    /// Sets the value of [gpu_partition_size][crate::model::AcceleratorConfig::gpu_partition_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// let x = AcceleratorConfig::new().set_gpu_partition_size("example");
    /// ```
    pub fn set_gpu_partition_size<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.gpu_partition_size = v.into();
        self
    }

    /// Sets the value of [gpu_sharing_config][crate::model::AcceleratorConfig::gpu_sharing_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// use google_cloud_container_v1::model::GPUSharingConfig;
    /// let x = AcceleratorConfig::new().set_gpu_sharing_config(GPUSharingConfig::default()/* use setters */);
    /// ```
    pub fn set_gpu_sharing_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GPUSharingConfig>,
    {
        self.gpu_sharing_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_sharing_config][crate::model::AcceleratorConfig::gpu_sharing_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// use google_cloud_container_v1::model::GPUSharingConfig;
    /// let x = AcceleratorConfig::new().set_or_clear_gpu_sharing_config(Some(GPUSharingConfig::default()/* use setters */));
    /// let x = AcceleratorConfig::new().set_or_clear_gpu_sharing_config(None::<GPUSharingConfig>);
    /// ```
    pub fn set_or_clear_gpu_sharing_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GPUSharingConfig>,
    {
        self.gpu_sharing_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gpu_driver_installation_config][crate::model::AcceleratorConfig::gpu_driver_installation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// use google_cloud_container_v1::model::GPUDriverInstallationConfig;
    /// let x = AcceleratorConfig::new().set_gpu_driver_installation_config(GPUDriverInstallationConfig::default()/* use setters */);
    /// ```
    pub fn set_gpu_driver_installation_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GPUDriverInstallationConfig>,
    {
        self.gpu_driver_installation_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_driver_installation_config][crate::model::AcceleratorConfig::gpu_driver_installation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AcceleratorConfig;
    /// use google_cloud_container_v1::model::GPUDriverInstallationConfig;
    /// let x = AcceleratorConfig::new().set_or_clear_gpu_driver_installation_config(Some(GPUDriverInstallationConfig::default()/* use setters */));
    /// let x = AcceleratorConfig::new().set_or_clear_gpu_driver_installation_config(None::<GPUDriverInstallationConfig>);
    /// ```
    pub fn set_or_clear_gpu_driver_installation_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::GPUDriverInstallationConfig>,
    {
        self.gpu_driver_installation_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AcceleratorConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AcceleratorConfig"
    }
}

/// GPUSharingConfig represents the GPU sharing configuration for Hardware
/// Accelerators.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GPUSharingConfig {
    /// The max number of containers that can share a physical GPU.
    pub max_shared_clients_per_gpu: i64,

    /// The type of GPU sharing strategy to enable on the GPU node.
    pub gpu_sharing_strategy:
        std::option::Option<crate::model::gpu_sharing_config::GPUSharingStrategy>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GPUSharingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [max_shared_clients_per_gpu][crate::model::GPUSharingConfig::max_shared_clients_per_gpu].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUSharingConfig;
    /// let x = GPUSharingConfig::new().set_max_shared_clients_per_gpu(42);
    /// ```
    pub fn set_max_shared_clients_per_gpu<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.max_shared_clients_per_gpu = v.into();
        self
    }

    /// Sets the value of [gpu_sharing_strategy][crate::model::GPUSharingConfig::gpu_sharing_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUSharingConfig;
    /// use google_cloud_container_v1::model::gpu_sharing_config::GPUSharingStrategy;
    /// let x0 = GPUSharingConfig::new().set_gpu_sharing_strategy(GPUSharingStrategy::TimeSharing);
    /// let x1 = GPUSharingConfig::new().set_gpu_sharing_strategy(GPUSharingStrategy::Mps);
    /// ```
    pub fn set_gpu_sharing_strategy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::gpu_sharing_config::GPUSharingStrategy>,
    {
        self.gpu_sharing_strategy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_sharing_strategy][crate::model::GPUSharingConfig::gpu_sharing_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUSharingConfig;
    /// use google_cloud_container_v1::model::gpu_sharing_config::GPUSharingStrategy;
    /// let x0 = GPUSharingConfig::new().set_or_clear_gpu_sharing_strategy(Some(GPUSharingStrategy::TimeSharing));
    /// let x1 = GPUSharingConfig::new().set_or_clear_gpu_sharing_strategy(Some(GPUSharingStrategy::Mps));
    /// let x_none = GPUSharingConfig::new().set_or_clear_gpu_sharing_strategy(None::<GPUSharingStrategy>);
    /// ```
    pub fn set_or_clear_gpu_sharing_strategy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::gpu_sharing_config::GPUSharingStrategy>,
    {
        self.gpu_sharing_strategy = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for GPUSharingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GPUSharingConfig"
    }
}

/// Defines additional types related to [GPUSharingConfig].
pub mod gpu_sharing_config {
    #[allow(unused_imports)]
    use super::*;

    /// The type of GPU sharing strategy currently provided.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum GPUSharingStrategy {
        /// Default value.
        Unspecified,
        /// GPUs are time-shared between containers.
        TimeSharing,
        /// GPUs are shared between containers with NVIDIA MPS.
        Mps,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [GPUSharingStrategy::value] or
        /// [GPUSharingStrategy::name].
        UnknownValue(gpu_sharing_strategy::UnknownValue),
    }

    #[doc(hidden)]
    pub mod gpu_sharing_strategy {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl GPUSharingStrategy {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::TimeSharing => std::option::Option::Some(1),
                Self::Mps => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("GPU_SHARING_STRATEGY_UNSPECIFIED"),
                Self::TimeSharing => std::option::Option::Some("TIME_SHARING"),
                Self::Mps => std::option::Option::Some("MPS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for GPUSharingStrategy {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for GPUSharingStrategy {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for GPUSharingStrategy {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::TimeSharing,
                2 => Self::Mps,
                _ => Self::UnknownValue(gpu_sharing_strategy::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for GPUSharingStrategy {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "GPU_SHARING_STRATEGY_UNSPECIFIED" => Self::Unspecified,
                "TIME_SHARING" => Self::TimeSharing,
                "MPS" => Self::Mps,
                _ => Self::UnknownValue(gpu_sharing_strategy::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for GPUSharingStrategy {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::TimeSharing => serializer.serialize_i32(1),
                Self::Mps => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for GPUSharingStrategy {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<GPUSharingStrategy>::new(
                ".google.container.v1.GPUSharingConfig.GPUSharingStrategy",
            ))
        }
    }
}

/// GPUDriverInstallationConfig specifies the version of GPU driver to be auto
/// installed.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GPUDriverInstallationConfig {
    /// Mode for how the GPU driver is installed.
    pub gpu_driver_version:
        std::option::Option<crate::model::gpu_driver_installation_config::GPUDriverVersion>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GPUDriverInstallationConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [gpu_driver_version][crate::model::GPUDriverInstallationConfig::gpu_driver_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUDriverInstallationConfig;
    /// use google_cloud_container_v1::model::gpu_driver_installation_config::GPUDriverVersion;
    /// let x0 = GPUDriverInstallationConfig::new().set_gpu_driver_version(GPUDriverVersion::InstallationDisabled);
    /// let x1 = GPUDriverInstallationConfig::new().set_gpu_driver_version(GPUDriverVersion::Default);
    /// let x2 = GPUDriverInstallationConfig::new().set_gpu_driver_version(GPUDriverVersion::Latest);
    /// ```
    pub fn set_gpu_driver_version<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::gpu_driver_installation_config::GPUDriverVersion>,
    {
        self.gpu_driver_version = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_driver_version][crate::model::GPUDriverInstallationConfig::gpu_driver_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUDriverInstallationConfig;
    /// use google_cloud_container_v1::model::gpu_driver_installation_config::GPUDriverVersion;
    /// let x0 = GPUDriverInstallationConfig::new().set_or_clear_gpu_driver_version(Some(GPUDriverVersion::InstallationDisabled));
    /// let x1 = GPUDriverInstallationConfig::new().set_or_clear_gpu_driver_version(Some(GPUDriverVersion::Default));
    /// let x2 = GPUDriverInstallationConfig::new().set_or_clear_gpu_driver_version(Some(GPUDriverVersion::Latest));
    /// let x_none = GPUDriverInstallationConfig::new().set_or_clear_gpu_driver_version(None::<GPUDriverVersion>);
    /// ```
    pub fn set_or_clear_gpu_driver_version<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::gpu_driver_installation_config::GPUDriverVersion>,
    {
        self.gpu_driver_version = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for GPUDriverInstallationConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GPUDriverInstallationConfig"
    }
}

/// Defines additional types related to [GPUDriverInstallationConfig].
pub mod gpu_driver_installation_config {
    #[allow(unused_imports)]
    use super::*;

    /// The GPU driver version to install.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum GPUDriverVersion {
        /// Default value is to not install any GPU driver.
        Unspecified,
        /// Disable GPU driver auto installation and needs manual installation
        InstallationDisabled,
        /// "Default" GPU driver in COS and Ubuntu.
        Default,
        /// "Latest" GPU driver in COS.
        Latest,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [GPUDriverVersion::value] or
        /// [GPUDriverVersion::name].
        UnknownValue(gpu_driver_version::UnknownValue),
    }

    #[doc(hidden)]
    pub mod gpu_driver_version {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl GPUDriverVersion {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::InstallationDisabled => std::option::Option::Some(1),
                Self::Default => std::option::Option::Some(2),
                Self::Latest => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("GPU_DRIVER_VERSION_UNSPECIFIED"),
                Self::InstallationDisabled => std::option::Option::Some("INSTALLATION_DISABLED"),
                Self::Default => std::option::Option::Some("DEFAULT"),
                Self::Latest => std::option::Option::Some("LATEST"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for GPUDriverVersion {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for GPUDriverVersion {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for GPUDriverVersion {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::InstallationDisabled,
                2 => Self::Default,
                3 => Self::Latest,
                _ => Self::UnknownValue(gpu_driver_version::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for GPUDriverVersion {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "GPU_DRIVER_VERSION_UNSPECIFIED" => Self::Unspecified,
                "INSTALLATION_DISABLED" => Self::InstallationDisabled,
                "DEFAULT" => Self::Default,
                "LATEST" => Self::Latest,
                _ => Self::UnknownValue(gpu_driver_version::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for GPUDriverVersion {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::InstallationDisabled => serializer.serialize_i32(1),
                Self::Default => serializer.serialize_i32(2),
                Self::Latest => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for GPUDriverVersion {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<GPUDriverVersion>::new(
                ".google.container.v1.GPUDriverInstallationConfig.GPUDriverVersion",
            ))
        }
    }
}

/// WorkloadMetadataConfig defines the metadata configuration to expose to
/// workloads on the node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkloadMetadataConfig {
    /// Mode is the configuration for how to expose metadata to workloads running
    /// on the node pool.
    pub mode: crate::model::workload_metadata_config::Mode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl WorkloadMetadataConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::WorkloadMetadataConfig::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadMetadataConfig;
    /// use google_cloud_container_v1::model::workload_metadata_config::Mode;
    /// let x0 = WorkloadMetadataConfig::new().set_mode(Mode::GceMetadata);
    /// let x1 = WorkloadMetadataConfig::new().set_mode(Mode::GkeMetadata);
    /// ```
    pub fn set_mode<T: std::convert::Into<crate::model::workload_metadata_config::Mode>>(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }
}

impl wkt::message::Message for WorkloadMetadataConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.WorkloadMetadataConfig"
    }
}

/// Defines additional types related to [WorkloadMetadataConfig].
pub mod workload_metadata_config {
    #[allow(unused_imports)]
    use super::*;

    /// Mode is the configuration for how to expose metadata to workloads running
    /// on the node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// Not set.
        Unspecified,
        /// Expose all Compute Engine metadata to pods.
        GceMetadata,
        /// Run the GKE Metadata Server on this node. The GKE Metadata Server exposes
        /// a metadata API to workloads that is compatible with the V1 Compute
        /// Metadata APIs exposed by the Compute Engine and App Engine Metadata
        /// Servers. This feature can only be enabled if Workload Identity is enabled
        /// at the cluster level.
        GkeMetadata,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::GceMetadata => std::option::Option::Some(1),
                Self::GkeMetadata => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::GceMetadata => std::option::Option::Some("GCE_METADATA"),
                Self::GkeMetadata => std::option::Option::Some("GKE_METADATA"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::GceMetadata,
                2 => Self::GkeMetadata,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "GCE_METADATA" => Self::GceMetadata,
                "GKE_METADATA" => Self::GkeMetadata,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::GceMetadata => serializer.serialize_i32(1),
                Self::GkeMetadata => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.WorkloadMetadataConfig.Mode",
            ))
        }
    }
}

/// SetNetworkPolicyRequest enables/disables network policy for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetNetworkPolicyRequest {
    /// Deprecated. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub project_id: std::string::String,

    /// Deprecated. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides. This field has been deprecated and replaced
    /// by the name field.
    #[deprecated]
    pub zone: std::string::String,

    /// Deprecated. The name of the cluster.
    /// This field has been deprecated and replaced by the name field.
    #[deprecated]
    pub cluster_id: std::string::String,

    /// Required. Configuration options for the NetworkPolicy feature.
    pub network_policy: std::option::Option<crate::model::NetworkPolicy>,

    /// The name (project, location, cluster name) of the cluster to set networking
    /// policy. Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetNetworkPolicyRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetNetworkPolicyRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// let x = SetNetworkPolicyRequest::new().set_project_id("example");
    /// ```
    #[deprecated]
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetNetworkPolicyRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// let x = SetNetworkPolicyRequest::new().set_zone("example");
    /// ```
    #[deprecated]
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetNetworkPolicyRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// let x = SetNetworkPolicyRequest::new().set_cluster_id("example");
    /// ```
    #[deprecated]
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [network_policy][crate::model::SetNetworkPolicyRequest::network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// use google_cloud_container_v1::model::NetworkPolicy;
    /// let x = SetNetworkPolicyRequest::new().set_network_policy(NetworkPolicy::default()/* use setters */);
    /// ```
    pub fn set_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicy>,
    {
        self.network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_policy][crate::model::SetNetworkPolicyRequest::network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// use google_cloud_container_v1::model::NetworkPolicy;
    /// let x = SetNetworkPolicyRequest::new().set_or_clear_network_policy(Some(NetworkPolicy::default()/* use setters */));
    /// let x = SetNetworkPolicyRequest::new().set_or_clear_network_policy(None::<NetworkPolicy>);
    /// ```
    pub fn set_or_clear_network_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::NetworkPolicy>,
    {
        self.network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetNetworkPolicyRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetNetworkPolicyRequest;
    /// let x = SetNetworkPolicyRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetNetworkPolicyRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetNetworkPolicyRequest"
    }
}

/// SetMaintenancePolicyRequest sets the maintenance policy for a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SetMaintenancePolicyRequest {
    /// Required. The Google Developers Console [project ID or project
    /// number](https://cloud.google.com/resource-manager/docs/creating-managing-projects).
    pub project_id: std::string::String,

    /// Required. The name of the Google Compute Engine
    /// [zone](https://cloud.google.com/compute/docs/zones#available)
    /// in which the cluster resides.
    pub zone: std::string::String,

    /// Required. The name of the cluster to update.
    pub cluster_id: std::string::String,

    /// Required. The maintenance policy to be set for the cluster. An empty field
    /// clears the existing maintenance policy.
    pub maintenance_policy: std::option::Option<crate::model::MaintenancePolicy>,

    /// The name (project, location, cluster name) of the cluster to set
    /// maintenance policy.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SetMaintenancePolicyRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project_id][crate::model::SetMaintenancePolicyRequest::project_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// let x = SetMaintenancePolicyRequest::new().set_project_id("example");
    /// ```
    pub fn set_project_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project_id = v.into();
        self
    }

    /// Sets the value of [zone][crate::model::SetMaintenancePolicyRequest::zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// let x = SetMaintenancePolicyRequest::new().set_zone("example");
    /// ```
    pub fn set_zone<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.zone = v.into();
        self
    }

    /// Sets the value of [cluster_id][crate::model::SetMaintenancePolicyRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// let x = SetMaintenancePolicyRequest::new().set_cluster_id("example");
    /// ```
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

    /// Sets the value of [maintenance_policy][crate::model::SetMaintenancePolicyRequest::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// use google_cloud_container_v1::model::MaintenancePolicy;
    /// let x = SetMaintenancePolicyRequest::new().set_maintenance_policy(MaintenancePolicy::default()/* use setters */);
    /// ```
    pub fn set_maintenance_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [maintenance_policy][crate::model::SetMaintenancePolicyRequest::maintenance_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// use google_cloud_container_v1::model::MaintenancePolicy;
    /// let x = SetMaintenancePolicyRequest::new().set_or_clear_maintenance_policy(Some(MaintenancePolicy::default()/* use setters */));
    /// let x = SetMaintenancePolicyRequest::new().set_or_clear_maintenance_policy(None::<MaintenancePolicy>);
    /// ```
    pub fn set_or_clear_maintenance_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MaintenancePolicy>,
    {
        self.maintenance_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [name][crate::model::SetMaintenancePolicyRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SetMaintenancePolicyRequest;
    /// let x = SetMaintenancePolicyRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for SetMaintenancePolicyRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SetMaintenancePolicyRequest"
    }
}

/// StatusCondition describes why a cluster or a node pool has a certain status
/// (e.g., ERROR or DEGRADED).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StatusCondition {
    /// Machine-friendly representation of the condition
    /// Deprecated. Use canonical_code instead.
    #[deprecated]
    pub code: crate::model::status_condition::Code,

    /// Human-friendly representation of the condition
    pub message: std::string::String,

    /// Canonical code of the condition.
    pub canonical_code: google_cloud_rpc::model::Code,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl StatusCondition {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [code][crate::model::StatusCondition::code].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StatusCondition;
    /// use google_cloud_container_v1::model::status_condition::Code;
    /// let x0 = StatusCondition::new().set_code(Code::GceStockout);
    /// let x1 = StatusCondition::new().set_code(Code::GkeServiceAccountDeleted);
    /// let x2 = StatusCondition::new().set_code(Code::GceQuotaExceeded);
    /// ```
    #[deprecated]
    pub fn set_code<T: std::convert::Into<crate::model::status_condition::Code>>(
        mut self,
        v: T,
    ) -> Self {
        self.code = v.into();
        self
    }

    /// Sets the value of [message][crate::model::StatusCondition::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StatusCondition;
    /// let x = StatusCondition::new().set_message("example");
    /// ```
    pub fn set_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.message = v.into();
        self
    }

    /// Sets the value of [canonical_code][crate::model::StatusCondition::canonical_code].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::StatusCondition;
    /// use google_cloud_rpc::model::Code;
    /// let x0 = StatusCondition::new().set_canonical_code(Code::Cancelled);
    /// let x1 = StatusCondition::new().set_canonical_code(Code::Unknown);
    /// let x2 = StatusCondition::new().set_canonical_code(Code::InvalidArgument);
    /// ```
    pub fn set_canonical_code<T: std::convert::Into<google_cloud_rpc::model::Code>>(
        mut self,
        v: T,
    ) -> Self {
        self.canonical_code = v.into();
        self
    }
}

impl wkt::message::Message for StatusCondition {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.StatusCondition"
    }
}

/// Defines additional types related to [StatusCondition].
pub mod status_condition {
    #[allow(unused_imports)]
    use super::*;

    /// Code for each condition
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Code {
        /// UNKNOWN indicates a generic condition.
        Unknown,
        /// GCE_STOCKOUT indicates that Google Compute Engine resources are
        /// temporarily unavailable.
        GceStockout,
        /// GKE_SERVICE_ACCOUNT_DELETED indicates that the user deleted their robot
        /// service account.
        GkeServiceAccountDeleted,
        /// Google Compute Engine quota was exceeded.
        GceQuotaExceeded,
        /// Cluster state was manually changed by an SRE due to a system logic error.
        SetByOperator,
        /// Unable to perform an encrypt operation against the CloudKMS key used for
        /// etcd level encryption.
        CloudKmsKeyError,
        /// Cluster CA is expiring soon.
        CaExpiring,
        /// Node service account is missing permissions.
        NodeServiceAccountMissingPermissions,
        /// Cloud KMS key version used for etcd level encryption has been destroyed.
        /// This is a permanent error.
        CloudKmsKeyDestroyed,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Code::value] or
        /// [Code::name].
        UnknownValue(code::UnknownValue),
    }

    #[doc(hidden)]
    pub mod code {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Code {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::GceStockout => std::option::Option::Some(1),
                Self::GkeServiceAccountDeleted => std::option::Option::Some(2),
                Self::GceQuotaExceeded => std::option::Option::Some(3),
                Self::SetByOperator => std::option::Option::Some(4),
                Self::CloudKmsKeyError => std::option::Option::Some(7),
                Self::CaExpiring => std::option::Option::Some(9),
                Self::NodeServiceAccountMissingPermissions => std::option::Option::Some(10),
                Self::CloudKmsKeyDestroyed => std::option::Option::Some(11),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::GceStockout => std::option::Option::Some("GCE_STOCKOUT"),
                Self::GkeServiceAccountDeleted => {
                    std::option::Option::Some("GKE_SERVICE_ACCOUNT_DELETED")
                }
                Self::GceQuotaExceeded => std::option::Option::Some("GCE_QUOTA_EXCEEDED"),
                Self::SetByOperator => std::option::Option::Some("SET_BY_OPERATOR"),
                Self::CloudKmsKeyError => std::option::Option::Some("CLOUD_KMS_KEY_ERROR"),
                Self::CaExpiring => std::option::Option::Some("CA_EXPIRING"),
                Self::NodeServiceAccountMissingPermissions => {
                    std::option::Option::Some("NODE_SERVICE_ACCOUNT_MISSING_PERMISSIONS")
                }
                Self::CloudKmsKeyDestroyed => std::option::Option::Some("CLOUD_KMS_KEY_DESTROYED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Code {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Code {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Code {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::GceStockout,
                2 => Self::GkeServiceAccountDeleted,
                3 => Self::GceQuotaExceeded,
                4 => Self::SetByOperator,
                7 => Self::CloudKmsKeyError,
                9 => Self::CaExpiring,
                10 => Self::NodeServiceAccountMissingPermissions,
                11 => Self::CloudKmsKeyDestroyed,
                _ => Self::UnknownValue(code::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Code {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "GCE_STOCKOUT" => Self::GceStockout,
                "GKE_SERVICE_ACCOUNT_DELETED" => Self::GkeServiceAccountDeleted,
                "GCE_QUOTA_EXCEEDED" => Self::GceQuotaExceeded,
                "SET_BY_OPERATOR" => Self::SetByOperator,
                "CLOUD_KMS_KEY_ERROR" => Self::CloudKmsKeyError,
                "CA_EXPIRING" => Self::CaExpiring,
                "NODE_SERVICE_ACCOUNT_MISSING_PERMISSIONS" => {
                    Self::NodeServiceAccountMissingPermissions
                }
                "CLOUD_KMS_KEY_DESTROYED" => Self::CloudKmsKeyDestroyed,
                _ => Self::UnknownValue(code::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Code {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::GceStockout => serializer.serialize_i32(1),
                Self::GkeServiceAccountDeleted => serializer.serialize_i32(2),
                Self::GceQuotaExceeded => serializer.serialize_i32(3),
                Self::SetByOperator => serializer.serialize_i32(4),
                Self::CloudKmsKeyError => serializer.serialize_i32(7),
                Self::CaExpiring => serializer.serialize_i32(9),
                Self::NodeServiceAccountMissingPermissions => serializer.serialize_i32(10),
                Self::CloudKmsKeyDestroyed => serializer.serialize_i32(11),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Code {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Code>::new(
                ".google.container.v1.StatusCondition.Code",
            ))
        }
    }
}

/// NetworkConfig reports the relative names of network & subnetwork.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkConfig {
    /// Output only. The relative name of the Google Compute Engine
    /// [network](https://cloud.google.com/compute/docs/networks-and-firewalls#networks)
    /// to which the cluster is connected. Example:
    /// projects/my-project/global/networks/my-network
    pub network: std::string::String,

    /// Output only. The relative name of the Google Compute Engine
    /// [subnetwork](https://cloud.google.com/compute/docs/vpc)
    /// to which the cluster is connected. Example:
    /// projects/my-project/regions/us-central1/subnetworks/my-subnet
    pub subnetwork: std::string::String,

    /// Whether Intra-node visibility is enabled for this cluster.
    /// This makes same node pod to pod traffic visible for VPC network.
    pub enable_intra_node_visibility: bool,

    /// Whether the cluster disables default in-node sNAT rules. In-node sNAT rules
    /// will be disabled when default_snat_status is disabled. When disabled is set
    /// to false, default IP masquerade rules will be applied to the nodes to
    /// prevent sNAT on cluster internal traffic.
    pub default_snat_status: std::option::Option<crate::model::DefaultSnatStatus>,

    /// Whether L4ILB Subsetting is enabled for this cluster.
    pub enable_l4ilb_subsetting: bool,

    /// The desired datapath provider for this cluster. By default, uses the
    /// IPTables-based kube-proxy implementation.
    pub datapath_provider: crate::model::DatapathProvider,

    /// The desired state of IPv6 connectivity to Google Services.
    /// By default, no private IPv6 access to or from Google Services (all access
    /// will be via IPv4)
    pub private_ipv6_google_access: crate::model::PrivateIPv6GoogleAccess,

    /// DNSConfig contains clusterDNS config for this cluster.
    pub dns_config: std::option::Option<crate::model::DNSConfig>,

    /// ServiceExternalIPsConfig specifies if services with externalIPs field are
    /// blocked or not.
    pub service_external_ips_config: std::option::Option<crate::model::ServiceExternalIPsConfig>,

    /// GatewayAPIConfig contains the desired config of Gateway API on this
    /// cluster.
    pub gateway_api_config: std::option::Option<crate::model::GatewayAPIConfig>,

    /// Whether multi-networking is enabled for this cluster.
    pub enable_multi_networking: bool,

    /// Network bandwidth tier configuration.
    pub network_performance_config:
        std::option::Option<crate::model::network_config::ClusterNetworkPerformanceConfig>,

    /// Whether FQDN Network Policy is enabled on this cluster.
    pub enable_fqdn_network_policy: std::option::Option<bool>,

    /// Specify the details of in-transit encryption.
    /// Now named inter-node transparent encryption.
    pub in_transit_encryption_config: std::option::Option<crate::model::InTransitEncryptionConfig>,

    /// Whether CiliumClusterwideNetworkPolicy is enabled on this cluster.
    pub enable_cilium_clusterwide_network_policy: std::option::Option<bool>,

    /// Controls whether by default nodes have private IP addresses only.
    /// It is invalid to specify both [PrivateClusterConfig.enablePrivateNodes][]
    /// and this field at the same time.
    /// To update the default setting, use
    /// [ClusterUpdate.desired_default_enable_private_nodes][google.container.v1.ClusterUpdate.desired_default_enable_private_nodes]
    pub default_enable_private_nodes: std::option::Option<bool>,

    /// Optional. DataplaneV2Config specifies the DPv2 configuration.
    pub dataplane_v2_config: std::option::Option<crate::model::DataplaneV2Config>,

    /// Disable L4 load balancer VPC firewalls to enable firewall policies.
    pub disable_l4_lb_firewall_reconciliation: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NetworkConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [network][crate::model::NetworkConfig::network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_network("example");
    /// ```
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [subnetwork][crate::model::NetworkConfig::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [enable_intra_node_visibility][crate::model::NetworkConfig::enable_intra_node_visibility].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_enable_intra_node_visibility(true);
    /// ```
    pub fn set_enable_intra_node_visibility<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_intra_node_visibility = v.into();
        self
    }

    /// Sets the value of [default_snat_status][crate::model::NetworkConfig::default_snat_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DefaultSnatStatus;
    /// let x = NetworkConfig::new().set_default_snat_status(DefaultSnatStatus::default()/* use setters */);
    /// ```
    pub fn set_default_snat_status<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DefaultSnatStatus>,
    {
        self.default_snat_status = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [default_snat_status][crate::model::NetworkConfig::default_snat_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DefaultSnatStatus;
    /// let x = NetworkConfig::new().set_or_clear_default_snat_status(Some(DefaultSnatStatus::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_default_snat_status(None::<DefaultSnatStatus>);
    /// ```
    pub fn set_or_clear_default_snat_status<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DefaultSnatStatus>,
    {
        self.default_snat_status = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_l4ilb_subsetting][crate::model::NetworkConfig::enable_l4ilb_subsetting].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_enable_l4ilb_subsetting(true);
    /// ```
    pub fn set_enable_l4ilb_subsetting<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_l4ilb_subsetting = v.into();
        self
    }

    /// Sets the value of [datapath_provider][crate::model::NetworkConfig::datapath_provider].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DatapathProvider;
    /// let x0 = NetworkConfig::new().set_datapath_provider(DatapathProvider::LegacyDatapath);
    /// let x1 = NetworkConfig::new().set_datapath_provider(DatapathProvider::AdvancedDatapath);
    /// ```
    pub fn set_datapath_provider<T: std::convert::Into<crate::model::DatapathProvider>>(
        mut self,
        v: T,
    ) -> Self {
        self.datapath_provider = v.into();
        self
    }

    /// Sets the value of [private_ipv6_google_access][crate::model::NetworkConfig::private_ipv6_google_access].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::PrivateIPv6GoogleAccess;
    /// let x0 = NetworkConfig::new().set_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessDisabled);
    /// let x1 = NetworkConfig::new().set_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessToGoogle);
    /// let x2 = NetworkConfig::new().set_private_ipv6_google_access(PrivateIPv6GoogleAccess::PrivateIpv6GoogleAccessBidirectional);
    /// ```
    pub fn set_private_ipv6_google_access<
        T: std::convert::Into<crate::model::PrivateIPv6GoogleAccess>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.private_ipv6_google_access = v.into();
        self
    }

    /// Sets the value of [dns_config][crate::model::NetworkConfig::dns_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DNSConfig;
    /// let x = NetworkConfig::new().set_dns_config(DNSConfig::default()/* use setters */);
    /// ```
    pub fn set_dns_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DNSConfig>,
    {
        self.dns_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [dns_config][crate::model::NetworkConfig::dns_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DNSConfig;
    /// let x = NetworkConfig::new().set_or_clear_dns_config(Some(DNSConfig::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_dns_config(None::<DNSConfig>);
    /// ```
    pub fn set_or_clear_dns_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DNSConfig>,
    {
        self.dns_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [service_external_ips_config][crate::model::NetworkConfig::service_external_ips_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::ServiceExternalIPsConfig;
    /// let x = NetworkConfig::new().set_service_external_ips_config(ServiceExternalIPsConfig::default()/* use setters */);
    /// ```
    pub fn set_service_external_ips_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ServiceExternalIPsConfig>,
    {
        self.service_external_ips_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [service_external_ips_config][crate::model::NetworkConfig::service_external_ips_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::ServiceExternalIPsConfig;
    /// let x = NetworkConfig::new().set_or_clear_service_external_ips_config(Some(ServiceExternalIPsConfig::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_service_external_ips_config(None::<ServiceExternalIPsConfig>);
    /// ```
    pub fn set_or_clear_service_external_ips_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ServiceExternalIPsConfig>,
    {
        self.service_external_ips_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [gateway_api_config][crate::model::NetworkConfig::gateway_api_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::GatewayAPIConfig;
    /// let x = NetworkConfig::new().set_gateway_api_config(GatewayAPIConfig::default()/* use setters */);
    /// ```
    pub fn set_gateway_api_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::GatewayAPIConfig>,
    {
        self.gateway_api_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gateway_api_config][crate::model::NetworkConfig::gateway_api_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::GatewayAPIConfig;
    /// let x = NetworkConfig::new().set_or_clear_gateway_api_config(Some(GatewayAPIConfig::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_gateway_api_config(None::<GatewayAPIConfig>);
    /// ```
    pub fn set_or_clear_gateway_api_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::GatewayAPIConfig>,
    {
        self.gateway_api_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_multi_networking][crate::model::NetworkConfig::enable_multi_networking].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_enable_multi_networking(true);
    /// ```
    pub fn set_enable_multi_networking<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_multi_networking = v.into();
        self
    }

    /// Sets the value of [network_performance_config][crate::model::NetworkConfig::network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
    /// let x = NetworkConfig::new().set_network_performance_config(ClusterNetworkPerformanceConfig::default()/* use setters */);
    /// ```
    pub fn set_network_performance_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::network_config::ClusterNetworkPerformanceConfig>,
    {
        self.network_performance_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [network_performance_config][crate::model::NetworkConfig::network_performance_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
    /// let x = NetworkConfig::new().set_or_clear_network_performance_config(Some(ClusterNetworkPerformanceConfig::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_network_performance_config(None::<ClusterNetworkPerformanceConfig>);
    /// ```
    pub fn set_or_clear_network_performance_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::network_config::ClusterNetworkPerformanceConfig>,
    {
        self.network_performance_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_fqdn_network_policy][crate::model::NetworkConfig::enable_fqdn_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_enable_fqdn_network_policy(true);
    /// ```
    pub fn set_enable_fqdn_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_fqdn_network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_fqdn_network_policy][crate::model::NetworkConfig::enable_fqdn_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_or_clear_enable_fqdn_network_policy(Some(false));
    /// let x = NetworkConfig::new().set_or_clear_enable_fqdn_network_policy(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_fqdn_network_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_fqdn_network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [in_transit_encryption_config][crate::model::NetworkConfig::in_transit_encryption_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::InTransitEncryptionConfig;
    /// let x0 = NetworkConfig::new().set_in_transit_encryption_config(InTransitEncryptionConfig::InTransitEncryptionDisabled);
    /// let x1 = NetworkConfig::new().set_in_transit_encryption_config(InTransitEncryptionConfig::InTransitEncryptionInterNodeTransparent);
    /// ```
    pub fn set_in_transit_encryption_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::InTransitEncryptionConfig>,
    {
        self.in_transit_encryption_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [in_transit_encryption_config][crate::model::NetworkConfig::in_transit_encryption_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::InTransitEncryptionConfig;
    /// let x0 = NetworkConfig::new().set_or_clear_in_transit_encryption_config(Some(InTransitEncryptionConfig::InTransitEncryptionDisabled));
    /// let x1 = NetworkConfig::new().set_or_clear_in_transit_encryption_config(Some(InTransitEncryptionConfig::InTransitEncryptionInterNodeTransparent));
    /// let x_none = NetworkConfig::new().set_or_clear_in_transit_encryption_config(None::<InTransitEncryptionConfig>);
    /// ```
    pub fn set_or_clear_in_transit_encryption_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::InTransitEncryptionConfig>,
    {
        self.in_transit_encryption_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_cilium_clusterwide_network_policy][crate::model::NetworkConfig::enable_cilium_clusterwide_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_enable_cilium_clusterwide_network_policy(true);
    /// ```
    pub fn set_enable_cilium_clusterwide_network_policy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_cilium_clusterwide_network_policy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_cilium_clusterwide_network_policy][crate::model::NetworkConfig::enable_cilium_clusterwide_network_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_or_clear_enable_cilium_clusterwide_network_policy(Some(false));
    /// let x = NetworkConfig::new().set_or_clear_enable_cilium_clusterwide_network_policy(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_cilium_clusterwide_network_policy<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_cilium_clusterwide_network_policy = v.map(|x| x.into());
        self
    }

    /// Sets the value of [default_enable_private_nodes][crate::model::NetworkConfig::default_enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_default_enable_private_nodes(true);
    /// ```
    pub fn set_default_enable_private_nodes<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.default_enable_private_nodes = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [default_enable_private_nodes][crate::model::NetworkConfig::default_enable_private_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_or_clear_default_enable_private_nodes(Some(false));
    /// let x = NetworkConfig::new().set_or_clear_default_enable_private_nodes(None::<bool>);
    /// ```
    pub fn set_or_clear_default_enable_private_nodes<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.default_enable_private_nodes = v.map(|x| x.into());
        self
    }

    /// Sets the value of [dataplane_v2_config][crate::model::NetworkConfig::dataplane_v2_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DataplaneV2Config;
    /// let x = NetworkConfig::new().set_dataplane_v2_config(DataplaneV2Config::default()/* use setters */);
    /// ```
    pub fn set_dataplane_v2_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DataplaneV2Config>,
    {
        self.dataplane_v2_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [dataplane_v2_config][crate::model::NetworkConfig::dataplane_v2_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// use google_cloud_container_v1::model::DataplaneV2Config;
    /// let x = NetworkConfig::new().set_or_clear_dataplane_v2_config(Some(DataplaneV2Config::default()/* use setters */));
    /// let x = NetworkConfig::new().set_or_clear_dataplane_v2_config(None::<DataplaneV2Config>);
    /// ```
    pub fn set_or_clear_dataplane_v2_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DataplaneV2Config>,
    {
        self.dataplane_v2_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [disable_l4_lb_firewall_reconciliation][crate::model::NetworkConfig::disable_l4_lb_firewall_reconciliation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_disable_l4_lb_firewall_reconciliation(true);
    /// ```
    pub fn set_disable_l4_lb_firewall_reconciliation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.disable_l4_lb_firewall_reconciliation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [disable_l4_lb_firewall_reconciliation][crate::model::NetworkConfig::disable_l4_lb_firewall_reconciliation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkConfig;
    /// let x = NetworkConfig::new().set_or_clear_disable_l4_lb_firewall_reconciliation(Some(false));
    /// let x = NetworkConfig::new().set_or_clear_disable_l4_lb_firewall_reconciliation(None::<bool>);
    /// ```
    pub fn set_or_clear_disable_l4_lb_firewall_reconciliation<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.disable_l4_lb_firewall_reconciliation = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NetworkConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NetworkConfig"
    }
}

/// Defines additional types related to [NetworkConfig].
pub mod network_config {
    #[allow(unused_imports)]
    use super::*;

    /// Configuration of network bandwidth tiers
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ClusterNetworkPerformanceConfig {
        /// Specifies the total network bandwidth tier for NodePools in the cluster.
        pub total_egress_bandwidth_tier: std::option::Option<
            crate::model::network_config::cluster_network_performance_config::Tier,
        >,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ClusterNetworkPerformanceConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [total_egress_bandwidth_tier][crate::model::network_config::ClusterNetworkPerformanceConfig::total_egress_bandwidth_tier].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
        /// use google_cloud_container_v1::model::network_config::cluster_network_performance_config::Tier;
        /// let x0 = ClusterNetworkPerformanceConfig::new().set_total_egress_bandwidth_tier(Tier::Tier1);
        /// ```
        pub fn set_total_egress_bandwidth_tier<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<
                    crate::model::network_config::cluster_network_performance_config::Tier,
                >,
        {
            self.total_egress_bandwidth_tier = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [total_egress_bandwidth_tier][crate::model::network_config::ClusterNetworkPerformanceConfig::total_egress_bandwidth_tier].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::network_config::ClusterNetworkPerformanceConfig;
        /// use google_cloud_container_v1::model::network_config::cluster_network_performance_config::Tier;
        /// let x0 = ClusterNetworkPerformanceConfig::new().set_or_clear_total_egress_bandwidth_tier(Some(Tier::Tier1));
        /// let x_none = ClusterNetworkPerformanceConfig::new().set_or_clear_total_egress_bandwidth_tier(None::<Tier>);
        /// ```
        pub fn set_or_clear_total_egress_bandwidth_tier<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<
                    crate::model::network_config::cluster_network_performance_config::Tier,
                >,
        {
            self.total_egress_bandwidth_tier = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for ClusterNetworkPerformanceConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NetworkConfig.ClusterNetworkPerformanceConfig"
        }
    }

    /// Defines additional types related to [ClusterNetworkPerformanceConfig].
    pub mod cluster_network_performance_config {
        #[allow(unused_imports)]
        use super::*;

        /// Node network tier
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Tier {
            /// Default value
            Unspecified,
            /// Higher bandwidth, actual values based on VM size.
            Tier1,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Tier::value] or
            /// [Tier::name].
            UnknownValue(tier::UnknownValue),
        }

        #[doc(hidden)]
        pub mod tier {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Tier {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Tier1 => std::option::Option::Some(1),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("TIER_UNSPECIFIED"),
                    Self::Tier1 => std::option::Option::Some("TIER_1"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Tier {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Tier {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Tier {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Tier1,
                    _ => Self::UnknownValue(tier::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Tier {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "TIER_UNSPECIFIED" => Self::Unspecified,
                    "TIER_1" => Self::Tier1,
                    _ => Self::UnknownValue(tier::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Tier {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Tier1 => serializer.serialize_i32(1),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Tier {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Tier>::new(
                    ".google.container.v1.NetworkConfig.ClusterNetworkPerformanceConfig.Tier",
                ))
            }
        }
    }
}

/// GatewayAPIConfig contains the desired config of Gateway API on this cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GatewayAPIConfig {
    /// The Gateway API release channel to use for Gateway API.
    pub channel: crate::model::gateway_api_config::Channel,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GatewayAPIConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [channel][crate::model::GatewayAPIConfig::channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GatewayAPIConfig;
    /// use google_cloud_container_v1::model::gateway_api_config::Channel;
    /// let x0 = GatewayAPIConfig::new().set_channel(Channel::Disabled);
    /// let x1 = GatewayAPIConfig::new().set_channel(Channel::Standard);
    /// ```
    pub fn set_channel<T: std::convert::Into<crate::model::gateway_api_config::Channel>>(
        mut self,
        v: T,
    ) -> Self {
        self.channel = v.into();
        self
    }
}

impl wkt::message::Message for GatewayAPIConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GatewayAPIConfig"
    }
}

/// Defines additional types related to [GatewayAPIConfig].
pub mod gateway_api_config {
    #[allow(unused_imports)]
    use super::*;

    /// Channel describes if/how Gateway API should be installed and implemented in
    /// a cluster.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Channel {
        /// Default value.
        Unspecified,
        /// Gateway API support is disabled
        Disabled,
        /// Deprecated: use CHANNEL_STANDARD instead.
        /// Gateway API support is enabled, experimental CRDs are installed
        #[deprecated]
        Experimental,
        /// Gateway API support is enabled, standard CRDs are installed
        Standard,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Channel::value] or
        /// [Channel::name].
        UnknownValue(channel::UnknownValue),
    }

    #[doc(hidden)]
    pub mod channel {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Channel {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::Experimental => std::option::Option::Some(3),
                Self::Standard => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("CHANNEL_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("CHANNEL_DISABLED"),
                Self::Experimental => std::option::Option::Some("CHANNEL_EXPERIMENTAL"),
                Self::Standard => std::option::Option::Some("CHANNEL_STANDARD"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Channel {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Channel {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Channel {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                3 => Self::Experimental,
                4 => Self::Standard,
                _ => Self::UnknownValue(channel::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Channel {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CHANNEL_UNSPECIFIED" => Self::Unspecified,
                "CHANNEL_DISABLED" => Self::Disabled,
                "CHANNEL_EXPERIMENTAL" => Self::Experimental,
                "CHANNEL_STANDARD" => Self::Standard,
                _ => Self::UnknownValue(channel::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Channel {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::Experimental => serializer.serialize_i32(3),
                Self::Standard => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Channel {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Channel>::new(
                ".google.container.v1.GatewayAPIConfig.Channel",
            ))
        }
    }
}

/// Config to block services with externalIPs field.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ServiceExternalIPsConfig {
    /// Whether Services with ExternalIPs field are allowed or not.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ServiceExternalIPsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ServiceExternalIPsConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ServiceExternalIPsConfig;
    /// let x = ServiceExternalIPsConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ServiceExternalIPsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ServiceExternalIPsConfig"
    }
}

/// GetOpenIDConfigRequest gets the OIDC discovery document for the
/// cluster. See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetOpenIDConfigRequest {
    /// The cluster (project, location, cluster name) to get the discovery document
    /// for. Specified in the format `projects/*/locations/*/clusters/*`.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetOpenIDConfigRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::GetOpenIDConfigRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigRequest;
    /// let x = GetOpenIDConfigRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for GetOpenIDConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetOpenIDConfigRequest"
    }
}

/// GetOpenIDConfigResponse is an OIDC discovery document for the cluster.
/// See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetOpenIDConfigResponse {
    /// OIDC Issuer.
    pub issuer: std::string::String,

    /// JSON Web Key uri.
    pub jwks_uri: std::string::String,

    /// Supported response types.
    pub response_types_supported: std::vec::Vec<std::string::String>,

    /// Supported subject types.
    pub subject_types_supported: std::vec::Vec<std::string::String>,

    /// supported ID Token signing Algorithms.
    pub id_token_signing_alg_values_supported: std::vec::Vec<std::string::String>,

    /// Supported claims.
    pub claims_supported: std::vec::Vec<std::string::String>,

    /// Supported grant types.
    pub grant_types: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetOpenIDConfigResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [issuer][crate::model::GetOpenIDConfigResponse::issuer].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_issuer("example");
    /// ```
    pub fn set_issuer<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.issuer = v.into();
        self
    }

    /// Sets the value of [jwks_uri][crate::model::GetOpenIDConfigResponse::jwks_uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_jwks_uri("example");
    /// ```
    pub fn set_jwks_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.jwks_uri = v.into();
        self
    }

    /// Sets the value of [response_types_supported][crate::model::GetOpenIDConfigResponse::response_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_response_types_supported(["a", "b", "c"]);
    /// ```
    pub fn set_response_types_supported<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.response_types_supported = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [subject_types_supported][crate::model::GetOpenIDConfigResponse::subject_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_subject_types_supported(["a", "b", "c"]);
    /// ```
    pub fn set_subject_types_supported<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.subject_types_supported = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [id_token_signing_alg_values_supported][crate::model::GetOpenIDConfigResponse::id_token_signing_alg_values_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_id_token_signing_alg_values_supported(["a", "b", "c"]);
    /// ```
    pub fn set_id_token_signing_alg_values_supported<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.id_token_signing_alg_values_supported = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [claims_supported][crate::model::GetOpenIDConfigResponse::claims_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_claims_supported(["a", "b", "c"]);
    /// ```
    pub fn set_claims_supported<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.claims_supported = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [grant_types][crate::model::GetOpenIDConfigResponse::grant_types].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetOpenIDConfigResponse;
    /// let x = GetOpenIDConfigResponse::new().set_grant_types(["a", "b", "c"]);
    /// ```
    pub fn set_grant_types<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.grant_types = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for GetOpenIDConfigResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetOpenIDConfigResponse"
    }
}

/// GetJSONWebKeysRequest gets the public component of the keys used by the
/// cluster to sign token requests. This will be the jwks_uri for the discover
/// document returned by getOpenIDConfig. See the OpenID Connect
/// Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetJSONWebKeysRequest {
    /// The cluster (project, location, cluster name) to get keys for. Specified in
    /// the format `projects/*/locations/*/clusters/*`.
    pub parent: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetJSONWebKeysRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::GetJSONWebKeysRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetJSONWebKeysRequest;
    /// let x = GetJSONWebKeysRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }
}

impl wkt::message::Message for GetJSONWebKeysRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetJSONWebKeysRequest"
    }
}

/// Jwk is a JSON Web Key as specified in RFC 7517
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Jwk {
    /// Key Type.
    pub kty: std::string::String,

    /// Algorithm.
    pub alg: std::string::String,

    /// Permitted uses for the public keys.
    pub r#use: std::string::String,

    /// Key ID.
    pub kid: std::string::String,

    /// Used for RSA keys.
    pub n: std::string::String,

    /// Used for RSA keys.
    pub e: std::string::String,

    /// Used for ECDSA keys.
    pub x: std::string::String,

    /// Used for ECDSA keys.
    pub y: std::string::String,

    /// Used for ECDSA keys.
    pub crv: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Jwk {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [kty][crate::model::Jwk::kty].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_kty("example");
    /// ```
    pub fn set_kty<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.kty = v.into();
        self
    }

    /// Sets the value of [alg][crate::model::Jwk::alg].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_alg("example");
    /// ```
    pub fn set_alg<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.alg = v.into();
        self
    }

    /// Sets the value of [r#use][crate::model::Jwk::use].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_use("example");
    /// ```
    pub fn set_use<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.r#use = v.into();
        self
    }

    /// Sets the value of [kid][crate::model::Jwk::kid].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_kid("example");
    /// ```
    pub fn set_kid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.kid = v.into();
        self
    }

    /// Sets the value of [n][crate::model::Jwk::n].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_n("example");
    /// ```
    pub fn set_n<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.n = v.into();
        self
    }

    /// Sets the value of [e][crate::model::Jwk::e].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_e("example");
    /// ```
    pub fn set_e<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.e = v.into();
        self
    }

    /// Sets the value of [x][crate::model::Jwk::x].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_x("example");
    /// ```
    pub fn set_x<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.x = v.into();
        self
    }

    /// Sets the value of [y][crate::model::Jwk::y].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_y("example");
    /// ```
    pub fn set_y<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.y = v.into();
        self
    }

    /// Sets the value of [crv][crate::model::Jwk::crv].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Jwk;
    /// let x = Jwk::new().set_crv("example");
    /// ```
    pub fn set_crv<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.crv = v.into();
        self
    }
}

impl wkt::message::Message for Jwk {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.Jwk"
    }
}

/// GetJSONWebKeysResponse is a valid JSON Web Key Set as specified in rfc 7517
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetJSONWebKeysResponse {
    /// The public component of the keys used by the cluster to sign token
    /// requests.
    pub keys: std::vec::Vec<crate::model::Jwk>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetJSONWebKeysResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [keys][crate::model::GetJSONWebKeysResponse::keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GetJSONWebKeysResponse;
    /// use google_cloud_container_v1::model::Jwk;
    /// let x = GetJSONWebKeysResponse::new()
    ///     .set_keys([
    ///         Jwk::default()/* use setters */,
    ///         Jwk::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_keys<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::Jwk>,
    {
        use std::iter::Iterator;
        self.keys = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for GetJSONWebKeysResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GetJSONWebKeysResponse"
    }
}

/// CheckAutopilotCompatibilityRequest requests getting the blockers for the
/// given operation in the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CheckAutopilotCompatibilityRequest {
    /// The name (project, location, cluster) of the cluster to retrieve.
    /// Specified in the format `projects/*/locations/*/clusters/*`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CheckAutopilotCompatibilityRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::CheckAutopilotCompatibilityRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CheckAutopilotCompatibilityRequest;
    /// let x = CheckAutopilotCompatibilityRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for CheckAutopilotCompatibilityRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CheckAutopilotCompatibilityRequest"
    }
}

/// AutopilotCompatibilityIssue contains information about a specific
/// compatibility issue with Autopilot mode.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AutopilotCompatibilityIssue {
    /// The last time when this issue was observed.
    pub last_observation: std::option::Option<wkt::Timestamp>,

    /// The constraint type of the issue.
    pub constraint_type: std::string::String,

    /// The incompatibility type of this issue.
    pub incompatibility_type: crate::model::autopilot_compatibility_issue::IssueType,

    /// The name of the resources which are subject to this issue.
    pub subjects: std::vec::Vec<std::string::String>,

    /// A URL to a public documentation, which addresses resolving this issue.
    pub documentation_url: std::string::String,

    /// The description of the issue.
    pub description: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AutopilotCompatibilityIssue {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [last_observation][crate::model::AutopilotCompatibilityIssue::last_observation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// use wkt::Timestamp;
    /// let x = AutopilotCompatibilityIssue::new().set_last_observation(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_last_observation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_observation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [last_observation][crate::model::AutopilotCompatibilityIssue::last_observation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// use wkt::Timestamp;
    /// let x = AutopilotCompatibilityIssue::new().set_or_clear_last_observation(Some(Timestamp::default()/* use setters */));
    /// let x = AutopilotCompatibilityIssue::new().set_or_clear_last_observation(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_last_observation<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.last_observation = v.map(|x| x.into());
        self
    }

    /// Sets the value of [constraint_type][crate::model::AutopilotCompatibilityIssue::constraint_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// let x = AutopilotCompatibilityIssue::new().set_constraint_type("example");
    /// ```
    pub fn set_constraint_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.constraint_type = v.into();
        self
    }

    /// Sets the value of [incompatibility_type][crate::model::AutopilotCompatibilityIssue::incompatibility_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// use google_cloud_container_v1::model::autopilot_compatibility_issue::IssueType;
    /// let x0 = AutopilotCompatibilityIssue::new().set_incompatibility_type(IssueType::Incompatibility);
    /// let x1 = AutopilotCompatibilityIssue::new().set_incompatibility_type(IssueType::AdditionalConfigRequired);
    /// let x2 = AutopilotCompatibilityIssue::new().set_incompatibility_type(IssueType::PassedWithOptionalConfig);
    /// ```
    pub fn set_incompatibility_type<
        T: std::convert::Into<crate::model::autopilot_compatibility_issue::IssueType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.incompatibility_type = v.into();
        self
    }

    /// Sets the value of [subjects][crate::model::AutopilotCompatibilityIssue::subjects].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// let x = AutopilotCompatibilityIssue::new().set_subjects(["a", "b", "c"]);
    /// ```
    pub fn set_subjects<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.subjects = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [documentation_url][crate::model::AutopilotCompatibilityIssue::documentation_url].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// let x = AutopilotCompatibilityIssue::new().set_documentation_url("example");
    /// ```
    pub fn set_documentation_url<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.documentation_url = v.into();
        self
    }

    /// Sets the value of [description][crate::model::AutopilotCompatibilityIssue::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// let x = AutopilotCompatibilityIssue::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }
}

impl wkt::message::Message for AutopilotCompatibilityIssue {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AutopilotCompatibilityIssue"
    }
}

/// Defines additional types related to [AutopilotCompatibilityIssue].
pub mod autopilot_compatibility_issue {
    #[allow(unused_imports)]
    use super::*;

    /// The type of the reported issue.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum IssueType {
        /// Default value, should not be used.
        Unspecified,
        /// Indicates that the issue is a known incompatibility between the
        /// cluster and Autopilot mode.
        Incompatibility,
        /// Indicates the issue is an incompatibility if customers take no further
        /// action to resolve.
        AdditionalConfigRequired,
        /// Indicates the issue is not an incompatibility, but depending on the
        /// workloads business logic, there is a potential that they won't work on
        /// Autopilot.
        PassedWithOptionalConfig,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [IssueType::value] or
        /// [IssueType::name].
        UnknownValue(issue_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod issue_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl IssueType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Incompatibility => std::option::Option::Some(1),
                Self::AdditionalConfigRequired => std::option::Option::Some(2),
                Self::PassedWithOptionalConfig => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("UNSPECIFIED"),
                Self::Incompatibility => std::option::Option::Some("INCOMPATIBILITY"),
                Self::AdditionalConfigRequired => {
                    std::option::Option::Some("ADDITIONAL_CONFIG_REQUIRED")
                }
                Self::PassedWithOptionalConfig => {
                    std::option::Option::Some("PASSED_WITH_OPTIONAL_CONFIG")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for IssueType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for IssueType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for IssueType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Incompatibility,
                2 => Self::AdditionalConfigRequired,
                3 => Self::PassedWithOptionalConfig,
                _ => Self::UnknownValue(issue_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for IssueType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNSPECIFIED" => Self::Unspecified,
                "INCOMPATIBILITY" => Self::Incompatibility,
                "ADDITIONAL_CONFIG_REQUIRED" => Self::AdditionalConfigRequired,
                "PASSED_WITH_OPTIONAL_CONFIG" => Self::PassedWithOptionalConfig,
                _ => Self::UnknownValue(issue_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for IssueType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Incompatibility => serializer.serialize_i32(1),
                Self::AdditionalConfigRequired => serializer.serialize_i32(2),
                Self::PassedWithOptionalConfig => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for IssueType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<IssueType>::new(
                ".google.container.v1.AutopilotCompatibilityIssue.IssueType",
            ))
        }
    }
}

/// CheckAutopilotCompatibilityResponse has a list of compatibility issues.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CheckAutopilotCompatibilityResponse {
    /// The list of issues for the given operation.
    pub issues: std::vec::Vec<crate::model::AutopilotCompatibilityIssue>,

    /// The summary of the autopilot compatibility response.
    pub summary: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CheckAutopilotCompatibilityResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [issues][crate::model::CheckAutopilotCompatibilityResponse::issues].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CheckAutopilotCompatibilityResponse;
    /// use google_cloud_container_v1::model::AutopilotCompatibilityIssue;
    /// let x = CheckAutopilotCompatibilityResponse::new()
    ///     .set_issues([
    ///         AutopilotCompatibilityIssue::default()/* use setters */,
    ///         AutopilotCompatibilityIssue::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_issues<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AutopilotCompatibilityIssue>,
    {
        use std::iter::Iterator;
        self.issues = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [summary][crate::model::CheckAutopilotCompatibilityResponse::summary].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CheckAutopilotCompatibilityResponse;
    /// let x = CheckAutopilotCompatibilityResponse::new().set_summary("example");
    /// ```
    pub fn set_summary<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.summary = v.into();
        self
    }
}

impl wkt::message::Message for CheckAutopilotCompatibilityResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CheckAutopilotCompatibilityResponse"
    }
}

/// ReleaseChannel indicates which release channel a cluster is
/// subscribed to. Release channels are arranged in order of risk.
///
/// When a cluster is subscribed to a release channel, Google maintains
/// both the master version and the node version. Node auto-upgrade
/// defaults to true and cannot be disabled.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ReleaseChannel {
    /// channel specifies which release channel the cluster is subscribed to.
    pub channel: crate::model::release_channel::Channel,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ReleaseChannel {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [channel][crate::model::ReleaseChannel::channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ReleaseChannel;
    /// use google_cloud_container_v1::model::release_channel::Channel;
    /// let x0 = ReleaseChannel::new().set_channel(Channel::Rapid);
    /// let x1 = ReleaseChannel::new().set_channel(Channel::Regular);
    /// let x2 = ReleaseChannel::new().set_channel(Channel::Stable);
    /// ```
    pub fn set_channel<T: std::convert::Into<crate::model::release_channel::Channel>>(
        mut self,
        v: T,
    ) -> Self {
        self.channel = v.into();
        self
    }
}

impl wkt::message::Message for ReleaseChannel {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ReleaseChannel"
    }
}

/// Defines additional types related to [ReleaseChannel].
pub mod release_channel {
    #[allow(unused_imports)]
    use super::*;

    /// Possible values for 'channel'.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Channel {
        /// No channel specified.
        Unspecified,
        /// RAPID channel is offered on an early access basis for customers who want
        /// to test new releases.
        ///
        /// WARNING: Versions available in the RAPID Channel may be subject to
        /// unresolved issues with no known workaround and are not subject to any
        /// SLAs.
        Rapid,
        /// Clusters subscribed to REGULAR receive versions that are considered GA
        /// quality. REGULAR is intended for production users who want to take
        /// advantage of new features.
        Regular,
        /// Clusters subscribed to STABLE receive versions that are known to be
        /// stable and reliable in production.
        Stable,
        /// Clusters subscribed to EXTENDED receive extended support and availability
        /// for versions which are known to be stable and reliable in production.
        Extended,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Channel::value] or
        /// [Channel::name].
        UnknownValue(channel::UnknownValue),
    }

    #[doc(hidden)]
    pub mod channel {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Channel {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Rapid => std::option::Option::Some(1),
                Self::Regular => std::option::Option::Some(2),
                Self::Stable => std::option::Option::Some(3),
                Self::Extended => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("UNSPECIFIED"),
                Self::Rapid => std::option::Option::Some("RAPID"),
                Self::Regular => std::option::Option::Some("REGULAR"),
                Self::Stable => std::option::Option::Some("STABLE"),
                Self::Extended => std::option::Option::Some("EXTENDED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Channel {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Channel {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Channel {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Rapid,
                2 => Self::Regular,
                3 => Self::Stable,
                4 => Self::Extended,
                _ => Self::UnknownValue(channel::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Channel {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNSPECIFIED" => Self::Unspecified,
                "RAPID" => Self::Rapid,
                "REGULAR" => Self::Regular,
                "STABLE" => Self::Stable,
                "EXTENDED" => Self::Extended,
                _ => Self::UnknownValue(channel::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Channel {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Rapid => serializer.serialize_i32(1),
                Self::Regular => serializer.serialize_i32(2),
                Self::Stable => serializer.serialize_i32(3),
                Self::Extended => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Channel {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Channel>::new(
                ".google.container.v1.ReleaseChannel.Channel",
            ))
        }
    }
}

/// Configuration for fine-grained cost management feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CostManagementConfig {
    /// Whether the feature is enabled or not.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CostManagementConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::CostManagementConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::CostManagementConfig;
    /// let x = CostManagementConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for CostManagementConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.CostManagementConfig"
    }
}

/// IntraNodeVisibilityConfig contains the desired config of the intra-node
/// visibility on this cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct IntraNodeVisibilityConfig {
    /// Enables intra node visibility for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl IntraNodeVisibilityConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::IntraNodeVisibilityConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IntraNodeVisibilityConfig;
    /// let x = IntraNodeVisibilityConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for IntraNodeVisibilityConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.IntraNodeVisibilityConfig"
    }
}

/// ILBSubsettingConfig contains the desired config of L4 Internal LoadBalancer
/// subsetting on this cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ILBSubsettingConfig {
    /// Enables l4 ILB subsetting for this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ILBSubsettingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ILBSubsettingConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ILBSubsettingConfig;
    /// let x = ILBSubsettingConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ILBSubsettingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ILBSubsettingConfig"
    }
}

/// DNSConfig contains the desired set of options for configuring clusterDNS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DNSConfig {
    /// cluster_dns indicates which in-cluster DNS provider should be used.
    pub cluster_dns: crate::model::dns_config::Provider,

    /// cluster_dns_scope indicates the scope of access to cluster DNS records.
    pub cluster_dns_scope: crate::model::dns_config::DNSScope,

    /// cluster_dns_domain is the suffix used for all cluster service records.
    pub cluster_dns_domain: std::string::String,

    /// Optional. The domain used in Additive VPC scope.
    pub additive_vpc_scope_dns_domain: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DNSConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [cluster_dns][crate::model::DNSConfig::cluster_dns].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DNSConfig;
    /// use google_cloud_container_v1::model::dns_config::Provider;
    /// let x0 = DNSConfig::new().set_cluster_dns(Provider::PlatformDefault);
    /// let x1 = DNSConfig::new().set_cluster_dns(Provider::CloudDns);
    /// let x2 = DNSConfig::new().set_cluster_dns(Provider::KubeDns);
    /// ```
    pub fn set_cluster_dns<T: std::convert::Into<crate::model::dns_config::Provider>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_dns = v.into();
        self
    }

    /// Sets the value of [cluster_dns_scope][crate::model::DNSConfig::cluster_dns_scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DNSConfig;
    /// use google_cloud_container_v1::model::dns_config::DNSScope;
    /// let x0 = DNSConfig::new().set_cluster_dns_scope(DNSScope::ClusterScope);
    /// let x1 = DNSConfig::new().set_cluster_dns_scope(DNSScope::VpcScope);
    /// ```
    pub fn set_cluster_dns_scope<T: std::convert::Into<crate::model::dns_config::DNSScope>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_dns_scope = v.into();
        self
    }

    /// Sets the value of [cluster_dns_domain][crate::model::DNSConfig::cluster_dns_domain].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DNSConfig;
    /// let x = DNSConfig::new().set_cluster_dns_domain("example");
    /// ```
    pub fn set_cluster_dns_domain<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_dns_domain = v.into();
        self
    }

    /// Sets the value of [additive_vpc_scope_dns_domain][crate::model::DNSConfig::additive_vpc_scope_dns_domain].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DNSConfig;
    /// let x = DNSConfig::new().set_additive_vpc_scope_dns_domain("example");
    /// ```
    pub fn set_additive_vpc_scope_dns_domain<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.additive_vpc_scope_dns_domain = v.into();
        self
    }
}

impl wkt::message::Message for DNSConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DNSConfig"
    }
}

/// Defines additional types related to [DNSConfig].
pub mod dns_config {
    #[allow(unused_imports)]
    use super::*;

    /// Provider lists the various in-cluster DNS providers.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Provider {
        /// Default value
        Unspecified,
        /// Use GKE default DNS provider(kube-dns) for DNS resolution.
        PlatformDefault,
        /// Use CloudDNS for DNS resolution.
        CloudDns,
        /// Use KubeDNS for DNS resolution.
        KubeDns,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Provider::value] or
        /// [Provider::name].
        UnknownValue(provider::UnknownValue),
    }

    #[doc(hidden)]
    pub mod provider {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Provider {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::PlatformDefault => std::option::Option::Some(1),
                Self::CloudDns => std::option::Option::Some(2),
                Self::KubeDns => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("PROVIDER_UNSPECIFIED"),
                Self::PlatformDefault => std::option::Option::Some("PLATFORM_DEFAULT"),
                Self::CloudDns => std::option::Option::Some("CLOUD_DNS"),
                Self::KubeDns => std::option::Option::Some("KUBE_DNS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Provider {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Provider {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Provider {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::PlatformDefault,
                2 => Self::CloudDns,
                3 => Self::KubeDns,
                _ => Self::UnknownValue(provider::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Provider {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PROVIDER_UNSPECIFIED" => Self::Unspecified,
                "PLATFORM_DEFAULT" => Self::PlatformDefault,
                "CLOUD_DNS" => Self::CloudDns,
                "KUBE_DNS" => Self::KubeDns,
                _ => Self::UnknownValue(provider::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Provider {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::PlatformDefault => serializer.serialize_i32(1),
                Self::CloudDns => serializer.serialize_i32(2),
                Self::KubeDns => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Provider {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Provider>::new(
                ".google.container.v1.DNSConfig.Provider",
            ))
        }
    }

    /// DNSScope lists the various scopes of access to cluster DNS records.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum DNSScope {
        /// Default value, will be inferred as cluster scope.
        Unspecified,
        /// DNS records are accessible from within the cluster.
        ClusterScope,
        /// DNS records are accessible from within the VPC.
        VpcScope,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [DNSScope::value] or
        /// [DNSScope::name].
        UnknownValue(dns_scope::UnknownValue),
    }

    #[doc(hidden)]
    pub mod dns_scope {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl DNSScope {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ClusterScope => std::option::Option::Some(1),
                Self::VpcScope => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("DNS_SCOPE_UNSPECIFIED"),
                Self::ClusterScope => std::option::Option::Some("CLUSTER_SCOPE"),
                Self::VpcScope => std::option::Option::Some("VPC_SCOPE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for DNSScope {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for DNSScope {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for DNSScope {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ClusterScope,
                2 => Self::VpcScope,
                _ => Self::UnknownValue(dns_scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for DNSScope {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "DNS_SCOPE_UNSPECIFIED" => Self::Unspecified,
                "CLUSTER_SCOPE" => Self::ClusterScope,
                "VPC_SCOPE" => Self::VpcScope,
                _ => Self::UnknownValue(dns_scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for DNSScope {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ClusterScope => serializer.serialize_i32(1),
                Self::VpcScope => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for DNSScope {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<DNSScope>::new(
                ".google.container.v1.DNSConfig.DNSScope",
            ))
        }
    }
}

/// Constraints applied to pods.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaxPodsConstraint {
    /// Constraint enforced on the max num of pods per node.
    pub max_pods_per_node: i64,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MaxPodsConstraint {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [max_pods_per_node][crate::model::MaxPodsConstraint::max_pods_per_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MaxPodsConstraint;
    /// let x = MaxPodsConstraint::new().set_max_pods_per_node(42);
    /// ```
    pub fn set_max_pods_per_node<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.max_pods_per_node = v.into();
        self
    }
}

impl wkt::message::Message for MaxPodsConstraint {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MaxPodsConstraint"
    }
}

/// Configuration for the use of Kubernetes Service Accounts in IAM policies.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkloadIdentityConfig {
    /// The workload pool to attach all Kubernetes service accounts to.
    pub workload_pool: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl WorkloadIdentityConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [workload_pool][crate::model::WorkloadIdentityConfig::workload_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadIdentityConfig;
    /// let x = WorkloadIdentityConfig::new().set_workload_pool("example");
    /// ```
    pub fn set_workload_pool<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.workload_pool = v.into();
        self
    }
}

impl wkt::message::Message for WorkloadIdentityConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.WorkloadIdentityConfig"
    }
}

/// IdentityServiceConfig is configuration for Identity Service which allows
/// customers to use external identity providers with the K8S API
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct IdentityServiceConfig {
    /// Whether to enable the Identity Service component
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl IdentityServiceConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::IdentityServiceConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::IdentityServiceConfig;
    /// let x = IdentityServiceConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for IdentityServiceConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.IdentityServiceConfig"
    }
}

/// Configuration for issuance of mTLS keys and certificates to Kubernetes pods.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MeshCertificates {
    /// enable_certificates controls issuance of workload mTLS certificates.
    ///
    /// If set, the GKE Workload Identity Certificates controller and node agent
    /// will be deployed in the cluster, which can then be configured by creating a
    /// WorkloadCertificateConfig Custom Resource.
    ///
    /// Requires Workload Identity
    /// ([workload_pool][google.container.v1.WorkloadIdentityConfig.workload_pool]
    /// must be non-empty).
    ///
    /// [google.container.v1.WorkloadIdentityConfig.workload_pool]: crate::model::WorkloadIdentityConfig::workload_pool
    pub enable_certificates: std::option::Option<wkt::BoolValue>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MeshCertificates {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_certificates][crate::model::MeshCertificates::enable_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MeshCertificates;
    /// use wkt::BoolValue;
    /// let x = MeshCertificates::new().set_enable_certificates(BoolValue::default()/* use setters */);
    /// ```
    pub fn set_enable_certificates<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::BoolValue>,
    {
        self.enable_certificates = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_certificates][crate::model::MeshCertificates::enable_certificates].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MeshCertificates;
    /// use wkt::BoolValue;
    /// let x = MeshCertificates::new().set_or_clear_enable_certificates(Some(BoolValue::default()/* use setters */));
    /// let x = MeshCertificates::new().set_or_clear_enable_certificates(None::<BoolValue>);
    /// ```
    pub fn set_or_clear_enable_certificates<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::BoolValue>,
    {
        self.enable_certificates = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for MeshCertificates {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MeshCertificates"
    }
}

/// Configuration of etcd encryption.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DatabaseEncryption {
    /// Name of CloudKMS key to use for the encryption of secrets in etcd.
    /// Ex. projects/my-project/locations/global/keyRings/my-ring/cryptoKeys/my-key
    pub key_name: std::string::String,

    /// The desired state of etcd encryption.
    pub state: crate::model::database_encryption::State,

    /// Output only. The current state of etcd encryption.
    pub current_state: std::option::Option<crate::model::database_encryption::CurrentState>,

    /// Output only. Keys in use by the cluster for decrypting
    /// existing objects, in addition to the key in `key_name`.
    ///
    /// Each item is a CloudKMS key resource.
    pub decryption_keys: std::vec::Vec<std::string::String>,

    /// Output only. Records errors seen during DatabaseEncryption update
    /// operations.
    pub last_operation_errors: std::vec::Vec<crate::model::database_encryption::OperationError>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DatabaseEncryption {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [key_name][crate::model::DatabaseEncryption::key_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = DatabaseEncryption::new().set_key_name("example");
    /// ```
    pub fn set_key_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.key_name = v.into();
        self
    }

    /// Sets the value of [state][crate::model::DatabaseEncryption::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// use google_cloud_container_v1::model::database_encryption::State;
    /// let x0 = DatabaseEncryption::new().set_state(State::Encrypted);
    /// let x1 = DatabaseEncryption::new().set_state(State::Decrypted);
    /// let x2 = DatabaseEncryption::new().set_state(State::AllObjectsEncryptionEnabled);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::database_encryption::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [current_state][crate::model::DatabaseEncryption::current_state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// use google_cloud_container_v1::model::database_encryption::CurrentState;
    /// let x0 = DatabaseEncryption::new().set_current_state(CurrentState::Encrypted);
    /// let x1 = DatabaseEncryption::new().set_current_state(CurrentState::Decrypted);
    /// let x2 = DatabaseEncryption::new().set_current_state(CurrentState::EncryptionPending);
    /// ```
    pub fn set_current_state<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::database_encryption::CurrentState>,
    {
        self.current_state = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [current_state][crate::model::DatabaseEncryption::current_state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// use google_cloud_container_v1::model::database_encryption::CurrentState;
    /// let x0 = DatabaseEncryption::new().set_or_clear_current_state(Some(CurrentState::Encrypted));
    /// let x1 = DatabaseEncryption::new().set_or_clear_current_state(Some(CurrentState::Decrypted));
    /// let x2 = DatabaseEncryption::new().set_or_clear_current_state(Some(CurrentState::EncryptionPending));
    /// let x_none = DatabaseEncryption::new().set_or_clear_current_state(None::<CurrentState>);
    /// ```
    pub fn set_or_clear_current_state<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::database_encryption::CurrentState>,
    {
        self.current_state = v.map(|x| x.into());
        self
    }

    /// Sets the value of [decryption_keys][crate::model::DatabaseEncryption::decryption_keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// let x = DatabaseEncryption::new().set_decryption_keys(["a", "b", "c"]);
    /// ```
    pub fn set_decryption_keys<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.decryption_keys = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [last_operation_errors][crate::model::DatabaseEncryption::last_operation_errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DatabaseEncryption;
    /// use google_cloud_container_v1::model::database_encryption::OperationError;
    /// let x = DatabaseEncryption::new()
    ///     .set_last_operation_errors([
    ///         OperationError::default()/* use setters */,
    ///         OperationError::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_last_operation_errors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::database_encryption::OperationError>,
    {
        use std::iter::Iterator;
        self.last_operation_errors = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for DatabaseEncryption {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DatabaseEncryption"
    }
}

/// Defines additional types related to [DatabaseEncryption].
pub mod database_encryption {
    #[allow(unused_imports)]
    use super::*;

    /// OperationError records errors seen from CloudKMS keys
    /// encountered during updates to DatabaseEncryption configuration.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct OperationError {
        /// CloudKMS key resource that had the error.
        pub key_name: std::string::String,

        /// Description of the error seen during the operation.
        pub error_message: std::string::String,

        /// Time when the CloudKMS error was seen.
        pub timestamp: std::option::Option<wkt::Timestamp>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl OperationError {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [key_name][crate::model::database_encryption::OperationError::key_name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::database_encryption::OperationError;
        /// let x = OperationError::new().set_key_name("example");
        /// ```
        pub fn set_key_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.key_name = v.into();
            self
        }

        /// Sets the value of [error_message][crate::model::database_encryption::OperationError::error_message].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::database_encryption::OperationError;
        /// let x = OperationError::new().set_error_message("example");
        /// ```
        pub fn set_error_message<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.error_message = v.into();
            self
        }

        /// Sets the value of [timestamp][crate::model::database_encryption::OperationError::timestamp].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::database_encryption::OperationError;
        /// use wkt::Timestamp;
        /// let x = OperationError::new().set_timestamp(Timestamp::default()/* use setters */);
        /// ```
        pub fn set_timestamp<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.timestamp = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [timestamp][crate::model::database_encryption::OperationError::timestamp].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::database_encryption::OperationError;
        /// use wkt::Timestamp;
        /// let x = OperationError::new().set_or_clear_timestamp(Some(Timestamp::default()/* use setters */));
        /// let x = OperationError::new().set_or_clear_timestamp(None::<Timestamp>);
        /// ```
        pub fn set_or_clear_timestamp<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Timestamp>,
        {
            self.timestamp = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for OperationError {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.DatabaseEncryption.OperationError"
        }
    }

    /// State of etcd encryption.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Should never be set
        Unknown,
        /// Secrets in etcd are encrypted.
        Encrypted,
        /// Secrets in etcd are stored in plain text (at etcd level) - this is
        /// unrelated to Compute Engine level full disk encryption.
        Decrypted,
        /// Encryption of all objects in the storage is enabled. There is no
        /// guarantee that all objects in the storage are encrypted, but eventually
        /// they will be.
        AllObjectsEncryptionEnabled,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl State {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Encrypted => std::option::Option::Some(1),
                Self::Decrypted => std::option::Option::Some(2),
                Self::AllObjectsEncryptionEnabled => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::Encrypted => std::option::Option::Some("ENCRYPTED"),
                Self::Decrypted => std::option::Option::Some("DECRYPTED"),
                Self::AllObjectsEncryptionEnabled => {
                    std::option::Option::Some("ALL_OBJECTS_ENCRYPTION_ENABLED")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for State {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for State {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Encrypted,
                2 => Self::Decrypted,
                3 => Self::AllObjectsEncryptionEnabled,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "ENCRYPTED" => Self::Encrypted,
                "DECRYPTED" => Self::Decrypted,
                "ALL_OBJECTS_ENCRYPTION_ENABLED" => Self::AllObjectsEncryptionEnabled,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Encrypted => serializer.serialize_i32(1),
                Self::Decrypted => serializer.serialize_i32(2),
                Self::AllObjectsEncryptionEnabled => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for State {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<State>::new(
                ".google.container.v1.DatabaseEncryption.State",
            ))
        }
    }

    /// Current State of etcd encryption.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum CurrentState {
        /// Should never be set
        Unspecified,
        /// Secrets in etcd are encrypted.
        Encrypted,
        /// Secrets in etcd are stored in plain text (at etcd level) - this is
        /// unrelated to Compute Engine level full disk encryption.
        Decrypted,
        /// Encryption (or re-encryption with a different CloudKMS key)
        /// of Secrets is in progress.
        EncryptionPending,
        /// Encryption (or re-encryption with a different CloudKMS key) of Secrets in
        /// etcd encountered an error.
        EncryptionError,
        /// De-crypting Secrets to plain text in etcd is in progress.
        DecryptionPending,
        /// De-crypting Secrets to plain text in etcd encountered an error.
        DecryptionError,
        /// Encryption of all objects in the storage is enabled.
        /// It does not guarantee that all objects in the storage are encrypted,
        /// but eventually they will be.
        AllObjectsEncryptionEnabled,
        /// Enablement of the encryption of all objects in storage is pending.
        AllObjectsEncryptionPending,
        /// Enabling encryption of all objects in storage encountered an error.
        AllObjectsEncryptionError,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [CurrentState::value] or
        /// [CurrentState::name].
        UnknownValue(current_state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod current_state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl CurrentState {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Encrypted => std::option::Option::Some(7),
                Self::Decrypted => std::option::Option::Some(2),
                Self::EncryptionPending => std::option::Option::Some(3),
                Self::EncryptionError => std::option::Option::Some(4),
                Self::DecryptionPending => std::option::Option::Some(5),
                Self::DecryptionError => std::option::Option::Some(6),
                Self::AllObjectsEncryptionEnabled => std::option::Option::Some(8),
                Self::AllObjectsEncryptionPending => std::option::Option::Some(9),
                Self::AllObjectsEncryptionError => std::option::Option::Some(10),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("CURRENT_STATE_UNSPECIFIED"),
                Self::Encrypted => std::option::Option::Some("CURRENT_STATE_ENCRYPTED"),
                Self::Decrypted => std::option::Option::Some("CURRENT_STATE_DECRYPTED"),
                Self::EncryptionPending => {
                    std::option::Option::Some("CURRENT_STATE_ENCRYPTION_PENDING")
                }
                Self::EncryptionError => {
                    std::option::Option::Some("CURRENT_STATE_ENCRYPTION_ERROR")
                }
                Self::DecryptionPending => {
                    std::option::Option::Some("CURRENT_STATE_DECRYPTION_PENDING")
                }
                Self::DecryptionError => {
                    std::option::Option::Some("CURRENT_STATE_DECRYPTION_ERROR")
                }
                Self::AllObjectsEncryptionEnabled => {
                    std::option::Option::Some("CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_ENABLED")
                }
                Self::AllObjectsEncryptionPending => {
                    std::option::Option::Some("CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_PENDING")
                }
                Self::AllObjectsEncryptionError => {
                    std::option::Option::Some("CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_ERROR")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for CurrentState {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for CurrentState {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for CurrentState {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                2 => Self::Decrypted,
                3 => Self::EncryptionPending,
                4 => Self::EncryptionError,
                5 => Self::DecryptionPending,
                6 => Self::DecryptionError,
                7 => Self::Encrypted,
                8 => Self::AllObjectsEncryptionEnabled,
                9 => Self::AllObjectsEncryptionPending,
                10 => Self::AllObjectsEncryptionError,
                _ => Self::UnknownValue(current_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for CurrentState {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CURRENT_STATE_UNSPECIFIED" => Self::Unspecified,
                "CURRENT_STATE_ENCRYPTED" => Self::Encrypted,
                "CURRENT_STATE_DECRYPTED" => Self::Decrypted,
                "CURRENT_STATE_ENCRYPTION_PENDING" => Self::EncryptionPending,
                "CURRENT_STATE_ENCRYPTION_ERROR" => Self::EncryptionError,
                "CURRENT_STATE_DECRYPTION_PENDING" => Self::DecryptionPending,
                "CURRENT_STATE_DECRYPTION_ERROR" => Self::DecryptionError,
                "CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_ENABLED" => Self::AllObjectsEncryptionEnabled,
                "CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_PENDING" => Self::AllObjectsEncryptionPending,
                "CURRENT_STATE_ALL_OBJECTS_ENCRYPTION_ERROR" => Self::AllObjectsEncryptionError,
                _ => Self::UnknownValue(current_state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for CurrentState {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Encrypted => serializer.serialize_i32(7),
                Self::Decrypted => serializer.serialize_i32(2),
                Self::EncryptionPending => serializer.serialize_i32(3),
                Self::EncryptionError => serializer.serialize_i32(4),
                Self::DecryptionPending => serializer.serialize_i32(5),
                Self::DecryptionError => serializer.serialize_i32(6),
                Self::AllObjectsEncryptionEnabled => serializer.serialize_i32(8),
                Self::AllObjectsEncryptionPending => serializer.serialize_i32(9),
                Self::AllObjectsEncryptionError => serializer.serialize_i32(10),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for CurrentState {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<CurrentState>::new(
                ".google.container.v1.DatabaseEncryption.CurrentState",
            ))
        }
    }
}

/// ListUsableSubnetworksRequest requests the list of usable subnetworks
/// available to a user for creating clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableSubnetworksRequest {
    /// The parent project where subnetworks are usable.
    /// Specified in the format `projects/*`.
    pub parent: std::string::String,

    /// Filtering currently only supports equality on the networkProjectId and must
    /// be in the form: "networkProjectId=[PROJECTID]", where `networkProjectId`
    /// is the project which owns the listed subnetworks. This defaults to the
    /// parent project ID.
    pub filter: std::string::String,

    /// The max number of results per page that should be returned. If the number
    /// of available results is larger than `page_size`, a `next_page_token` is
    /// returned which can be used to get the next page of results in subsequent
    /// requests. Acceptable values are 0 to 500, inclusive. (Default: 500)
    pub page_size: i32,

    /// Specifies a page token to use. Set this to the nextPageToken returned by
    /// previous list requests to get the next page of results.
    pub page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListUsableSubnetworksRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListUsableSubnetworksRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksRequest;
    /// let x = ListUsableSubnetworksRequest::new().set_parent("example");
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListUsableSubnetworksRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksRequest;
    /// let x = ListUsableSubnetworksRequest::new().set_filter("example");
    /// ```
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListUsableSubnetworksRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksRequest;
    /// let x = ListUsableSubnetworksRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListUsableSubnetworksRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksRequest;
    /// let x = ListUsableSubnetworksRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }
}

impl wkt::message::Message for ListUsableSubnetworksRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListUsableSubnetworksRequest"
    }
}

/// ListUsableSubnetworksResponse is the response of
/// ListUsableSubnetworksRequest.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListUsableSubnetworksResponse {
    /// A list of usable subnetworks in the specified network project.
    pub subnetworks: std::vec::Vec<crate::model::UsableSubnetwork>,

    /// This token allows you to get the next page of results for list requests.
    /// If the number of results is larger than `page_size`, use the
    /// `next_page_token` as a value for the query parameter `page_token` in the
    /// next request. The value will become empty when there are no more pages.
    pub next_page_token: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListUsableSubnetworksResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [subnetworks][crate::model::ListUsableSubnetworksResponse::subnetworks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksResponse;
    /// use google_cloud_container_v1::model::UsableSubnetwork;
    /// let x = ListUsableSubnetworksResponse::new()
    ///     .set_subnetworks([
    ///         UsableSubnetwork::default()/* use setters */,
    ///         UsableSubnetwork::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_subnetworks<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::UsableSubnetwork>,
    {
        use std::iter::Iterator;
        self.subnetworks = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListUsableSubnetworksResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ListUsableSubnetworksResponse;
    /// let x = ListUsableSubnetworksResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }
}

impl wkt::message::Message for ListUsableSubnetworksResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ListUsableSubnetworksResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListUsableSubnetworksResponse {
    type PageItem = crate::model::UsableSubnetwork;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.subnetworks
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Secondary IP range of a usable subnetwork.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UsableSubnetworkSecondaryRange {
    /// The name associated with this subnetwork secondary range, used when adding
    /// an alias IP range to a VM instance.
    pub range_name: std::string::String,

    /// The range of IP addresses belonging to this subnetwork secondary range.
    pub ip_cidr_range: std::string::String,

    /// This field is to determine the status of the secondary range programmably.
    pub status: crate::model::usable_subnetwork_secondary_range::Status,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UsableSubnetworkSecondaryRange {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [range_name][crate::model::UsableSubnetworkSecondaryRange::range_name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetworkSecondaryRange;
    /// let x = UsableSubnetworkSecondaryRange::new().set_range_name("example");
    /// ```
    pub fn set_range_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.range_name = v.into();
        self
    }

    /// Sets the value of [ip_cidr_range][crate::model::UsableSubnetworkSecondaryRange::ip_cidr_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetworkSecondaryRange;
    /// let x = UsableSubnetworkSecondaryRange::new().set_ip_cidr_range("example");
    /// ```
    pub fn set_ip_cidr_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.ip_cidr_range = v.into();
        self
    }

    /// Sets the value of [status][crate::model::UsableSubnetworkSecondaryRange::status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetworkSecondaryRange;
    /// use google_cloud_container_v1::model::usable_subnetwork_secondary_range::Status;
    /// let x0 = UsableSubnetworkSecondaryRange::new().set_status(Status::Unused);
    /// let x1 = UsableSubnetworkSecondaryRange::new().set_status(Status::InUseService);
    /// let x2 = UsableSubnetworkSecondaryRange::new().set_status(Status::InUseShareablePod);
    /// ```
    pub fn set_status<
        T: std::convert::Into<crate::model::usable_subnetwork_secondary_range::Status>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.status = v.into();
        self
    }
}

impl wkt::message::Message for UsableSubnetworkSecondaryRange {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UsableSubnetworkSecondaryRange"
    }
}

/// Defines additional types related to [UsableSubnetworkSecondaryRange].
pub mod usable_subnetwork_secondary_range {
    #[allow(unused_imports)]
    use super::*;

    /// Status shows the current usage of a secondary IP range.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Status {
        /// UNKNOWN is the zero value of the Status enum. It's not a valid status.
        Unknown,
        /// UNUSED denotes that this range is unclaimed by any cluster.
        Unused,
        /// IN_USE_SERVICE denotes that this range is claimed by cluster(s) for
        /// services. User-managed services range can be shared between clusters
        /// within the same subnetwork.
        InUseService,
        /// IN_USE_SHAREABLE_POD denotes this range was created by the network admin
        /// and is currently claimed by a cluster for pods. It can only be used by
        /// other clusters as a pod range.
        InUseShareablePod,
        /// IN_USE_MANAGED_POD denotes this range was created by GKE and is claimed
        /// for pods. It cannot be used for other clusters.
        InUseManagedPod,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Status::value] or
        /// [Status::name].
        UnknownValue(status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Status {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Unused => std::option::Option::Some(1),
                Self::InUseService => std::option::Option::Some(2),
                Self::InUseShareablePod => std::option::Option::Some(3),
                Self::InUseManagedPod => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::Unused => std::option::Option::Some("UNUSED"),
                Self::InUseService => std::option::Option::Some("IN_USE_SERVICE"),
                Self::InUseShareablePod => std::option::Option::Some("IN_USE_SHAREABLE_POD"),
                Self::InUseManagedPod => std::option::Option::Some("IN_USE_MANAGED_POD"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Status {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Status {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Status {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Unused,
                2 => Self::InUseService,
                3 => Self::InUseShareablePod,
                4 => Self::InUseManagedPod,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Status {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "UNUSED" => Self::Unused,
                "IN_USE_SERVICE" => Self::InUseService,
                "IN_USE_SHAREABLE_POD" => Self::InUseShareablePod,
                "IN_USE_MANAGED_POD" => Self::InUseManagedPod,
                _ => Self::UnknownValue(status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Status {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Unused => serializer.serialize_i32(1),
                Self::InUseService => serializer.serialize_i32(2),
                Self::InUseShareablePod => serializer.serialize_i32(3),
                Self::InUseManagedPod => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Status {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Status>::new(
                ".google.container.v1.UsableSubnetworkSecondaryRange.Status",
            ))
        }
    }
}

/// UsableSubnetwork resource returns the subnetwork name, its associated network
/// and the primary CIDR range.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UsableSubnetwork {
    /// Subnetwork Name.
    /// Example: projects/my-project/regions/us-central1/subnetworks/my-subnet
    pub subnetwork: std::string::String,

    /// Network Name.
    /// Example: projects/my-project/global/networks/my-network
    pub network: std::string::String,

    /// The range of internal addresses that are owned by this subnetwork.
    pub ip_cidr_range: std::string::String,

    /// Secondary IP ranges.
    pub secondary_ip_ranges: std::vec::Vec<crate::model::UsableSubnetworkSecondaryRange>,

    /// A human readable status message representing the reasons for cases where
    /// the caller cannot use the secondary ranges under the subnet. For example if
    /// the secondary_ip_ranges is empty due to a permission issue, an insufficient
    /// permission message will be given by status_message.
    pub status_message: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UsableSubnetwork {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [subnetwork][crate::model::UsableSubnetwork::subnetwork].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetwork;
    /// let x = UsableSubnetwork::new().set_subnetwork("example");
    /// ```
    pub fn set_subnetwork<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnetwork = v.into();
        self
    }

    /// Sets the value of [network][crate::model::UsableSubnetwork::network].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetwork;
    /// let x = UsableSubnetwork::new().set_network("example");
    /// ```
    pub fn set_network<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.network = v.into();
        self
    }

    /// Sets the value of [ip_cidr_range][crate::model::UsableSubnetwork::ip_cidr_range].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetwork;
    /// let x = UsableSubnetwork::new().set_ip_cidr_range("example");
    /// ```
    pub fn set_ip_cidr_range<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.ip_cidr_range = v.into();
        self
    }

    /// Sets the value of [secondary_ip_ranges][crate::model::UsableSubnetwork::secondary_ip_ranges].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetwork;
    /// use google_cloud_container_v1::model::UsableSubnetworkSecondaryRange;
    /// let x = UsableSubnetwork::new()
    ///     .set_secondary_ip_ranges([
    ///         UsableSubnetworkSecondaryRange::default()/* use setters */,
    ///         UsableSubnetworkSecondaryRange::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_secondary_ip_ranges<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::UsableSubnetworkSecondaryRange>,
    {
        use std::iter::Iterator;
        self.secondary_ip_ranges = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [status_message][crate::model::UsableSubnetwork::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UsableSubnetwork;
    /// let x = UsableSubnetwork::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }
}

impl wkt::message::Message for UsableSubnetwork {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UsableSubnetwork"
    }
}

/// Configuration for exporting cluster resource usages.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResourceUsageExportConfig {
    /// Configuration to use BigQuery as usage export destination.
    pub bigquery_destination:
        std::option::Option<crate::model::resource_usage_export_config::BigQueryDestination>,

    /// Whether to enable network egress metering for this cluster. If enabled, a
    /// daemonset will be created in the cluster to meter network egress traffic.
    pub enable_network_egress_metering: bool,

    /// Configuration to enable resource consumption metering.
    pub consumption_metering_config:
        std::option::Option<crate::model::resource_usage_export_config::ConsumptionMeteringConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ResourceUsageExportConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [bigquery_destination][crate::model::ResourceUsageExportConfig::bigquery_destination].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// use google_cloud_container_v1::model::resource_usage_export_config::BigQueryDestination;
    /// let x = ResourceUsageExportConfig::new().set_bigquery_destination(BigQueryDestination::default()/* use setters */);
    /// ```
    pub fn set_bigquery_destination<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::resource_usage_export_config::BigQueryDestination>,
    {
        self.bigquery_destination = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [bigquery_destination][crate::model::ResourceUsageExportConfig::bigquery_destination].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// use google_cloud_container_v1::model::resource_usage_export_config::BigQueryDestination;
    /// let x = ResourceUsageExportConfig::new().set_or_clear_bigquery_destination(Some(BigQueryDestination::default()/* use setters */));
    /// let x = ResourceUsageExportConfig::new().set_or_clear_bigquery_destination(None::<BigQueryDestination>);
    /// ```
    pub fn set_or_clear_bigquery_destination<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::resource_usage_export_config::BigQueryDestination>,
    {
        self.bigquery_destination = v.map(|x| x.into());
        self
    }

    /// Sets the value of [enable_network_egress_metering][crate::model::ResourceUsageExportConfig::enable_network_egress_metering].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// let x = ResourceUsageExportConfig::new().set_enable_network_egress_metering(true);
    /// ```
    pub fn set_enable_network_egress_metering<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_network_egress_metering = v.into();
        self
    }

    /// Sets the value of [consumption_metering_config][crate::model::ResourceUsageExportConfig::consumption_metering_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// use google_cloud_container_v1::model::resource_usage_export_config::ConsumptionMeteringConfig;
    /// let x = ResourceUsageExportConfig::new().set_consumption_metering_config(ConsumptionMeteringConfig::default()/* use setters */);
    /// ```
    pub fn set_consumption_metering_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<
                crate::model::resource_usage_export_config::ConsumptionMeteringConfig,
            >,
    {
        self.consumption_metering_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [consumption_metering_config][crate::model::ResourceUsageExportConfig::consumption_metering_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceUsageExportConfig;
    /// use google_cloud_container_v1::model::resource_usage_export_config::ConsumptionMeteringConfig;
    /// let x = ResourceUsageExportConfig::new().set_or_clear_consumption_metering_config(Some(ConsumptionMeteringConfig::default()/* use setters */));
    /// let x = ResourceUsageExportConfig::new().set_or_clear_consumption_metering_config(None::<ConsumptionMeteringConfig>);
    /// ```
    pub fn set_or_clear_consumption_metering_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<
                crate::model::resource_usage_export_config::ConsumptionMeteringConfig,
            >,
    {
        self.consumption_metering_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ResourceUsageExportConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ResourceUsageExportConfig"
    }
}

/// Defines additional types related to [ResourceUsageExportConfig].
pub mod resource_usage_export_config {
    #[allow(unused_imports)]
    use super::*;

    /// Parameters for using BigQuery as the destination of resource usage export.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct BigQueryDestination {
        /// The ID of a BigQuery Dataset.
        pub dataset_id: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl BigQueryDestination {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [dataset_id][crate::model::resource_usage_export_config::BigQueryDestination::dataset_id].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::resource_usage_export_config::BigQueryDestination;
        /// let x = BigQueryDestination::new().set_dataset_id("example");
        /// ```
        pub fn set_dataset_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.dataset_id = v.into();
            self
        }
    }

    impl wkt::message::Message for BigQueryDestination {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ResourceUsageExportConfig.BigQueryDestination"
        }
    }

    /// Parameters for controlling consumption metering.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ConsumptionMeteringConfig {
        /// Whether to enable consumption metering for this cluster. If enabled, a
        /// second BigQuery table will be created to hold resource consumption
        /// records.
        pub enabled: bool,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ConsumptionMeteringConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::resource_usage_export_config::ConsumptionMeteringConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::resource_usage_export_config::ConsumptionMeteringConfig;
        /// let x = ConsumptionMeteringConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }
    }

    impl wkt::message::Message for ConsumptionMeteringConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ResourceUsageExportConfig.ConsumptionMeteringConfig"
        }
    }
}

/// VerticalPodAutoscaling contains global, per-cluster information
/// required by Vertical Pod Autoscaler to automatically adjust
/// the resources of pods controlled by it.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VerticalPodAutoscaling {
    /// Enables vertical pod autoscaling.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl VerticalPodAutoscaling {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::VerticalPodAutoscaling::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::VerticalPodAutoscaling;
    /// let x = VerticalPodAutoscaling::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for VerticalPodAutoscaling {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.VerticalPodAutoscaling"
    }
}

/// DefaultSnatStatus contains the desired state of whether default sNAT should
/// be disabled on the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DefaultSnatStatus {
    /// Disables cluster default sNAT rules.
    pub disabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DefaultSnatStatus {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disabled][crate::model::DefaultSnatStatus::disabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DefaultSnatStatus;
    /// let x = DefaultSnatStatus::new().set_disabled(true);
    /// ```
    pub fn set_disabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.disabled = v.into();
        self
    }
}

impl wkt::message::Message for DefaultSnatStatus {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DefaultSnatStatus"
    }
}

/// Configuration of Shielded Nodes feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ShieldedNodes {
    /// Whether Shielded Nodes features are enabled on all nodes in this cluster.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ShieldedNodes {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ShieldedNodes::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ShieldedNodes;
    /// let x = ShieldedNodes::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ShieldedNodes {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ShieldedNodes"
    }
}

/// Configuration of gVNIC feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct VirtualNIC {
    /// Whether gVNIC features are enabled in the node pool.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl VirtualNIC {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::VirtualNIC::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::VirtualNIC;
    /// let x = VirtualNIC::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for VirtualNIC {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.VirtualNIC"
    }
}

/// Configuration of Fast Socket feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FastSocket {
    /// Whether Fast Socket features are enabled in the node pool.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FastSocket {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::FastSocket::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::FastSocket;
    /// let x = FastSocket::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for FastSocket {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.FastSocket"
    }
}

/// GPUDirectConfig specifies the GPU direct strategy on the node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GPUDirectConfig {
    /// The type of GPU direct strategy to enable on the node pool.
    pub gpu_direct_strategy:
        std::option::Option<crate::model::gpu_direct_config::GPUDirectStrategy>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GPUDirectConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [gpu_direct_strategy][crate::model::GPUDirectConfig::gpu_direct_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUDirectConfig;
    /// use google_cloud_container_v1::model::gpu_direct_config::GPUDirectStrategy;
    /// let x0 = GPUDirectConfig::new().set_gpu_direct_strategy(GPUDirectStrategy::Rdma);
    /// ```
    pub fn set_gpu_direct_strategy<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::gpu_direct_config::GPUDirectStrategy>,
    {
        self.gpu_direct_strategy = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [gpu_direct_strategy][crate::model::GPUDirectConfig::gpu_direct_strategy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GPUDirectConfig;
    /// use google_cloud_container_v1::model::gpu_direct_config::GPUDirectStrategy;
    /// let x0 = GPUDirectConfig::new().set_or_clear_gpu_direct_strategy(Some(GPUDirectStrategy::Rdma));
    /// let x_none = GPUDirectConfig::new().set_or_clear_gpu_direct_strategy(None::<GPUDirectStrategy>);
    /// ```
    pub fn set_or_clear_gpu_direct_strategy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::gpu_direct_config::GPUDirectStrategy>,
    {
        self.gpu_direct_strategy = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for GPUDirectConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GPUDirectConfig"
    }
}

/// Defines additional types related to [GPUDirectConfig].
pub mod gpu_direct_config {
    #[allow(unused_imports)]
    use super::*;

    /// Option for GPU direct Strategies
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum GPUDirectStrategy {
        /// Default value. No GPU Direct strategy is enabled on the node.
        Unspecified,
        /// GPUDirect-RDMA on A3 Ultra, and A4 machine types
        Rdma,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [GPUDirectStrategy::value] or
        /// [GPUDirectStrategy::name].
        UnknownValue(gpu_direct_strategy::UnknownValue),
    }

    #[doc(hidden)]
    pub mod gpu_direct_strategy {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl GPUDirectStrategy {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Rdma => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("GPU_DIRECT_STRATEGY_UNSPECIFIED"),
                Self::Rdma => std::option::Option::Some("RDMA"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for GPUDirectStrategy {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for GPUDirectStrategy {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for GPUDirectStrategy {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                2 => Self::Rdma,
                _ => Self::UnknownValue(gpu_direct_strategy::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for GPUDirectStrategy {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "GPU_DIRECT_STRATEGY_UNSPECIFIED" => Self::Unspecified,
                "RDMA" => Self::Rdma,
                _ => Self::UnknownValue(gpu_direct_strategy::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for GPUDirectStrategy {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Rdma => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for GPUDirectStrategy {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<GPUDirectStrategy>::new(
                ".google.container.v1.GPUDirectConfig.GPUDirectStrategy",
            ))
        }
    }
}

/// NotificationConfig is the configuration of notifications.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NotificationConfig {
    /// Notification config for Pub/Sub.
    pub pubsub: std::option::Option<crate::model::notification_config::PubSub>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NotificationConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [pubsub][crate::model::NotificationConfig::pubsub].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NotificationConfig;
    /// use google_cloud_container_v1::model::notification_config::PubSub;
    /// let x = NotificationConfig::new().set_pubsub(PubSub::default()/* use setters */);
    /// ```
    pub fn set_pubsub<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::notification_config::PubSub>,
    {
        self.pubsub = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pubsub][crate::model::NotificationConfig::pubsub].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NotificationConfig;
    /// use google_cloud_container_v1::model::notification_config::PubSub;
    /// let x = NotificationConfig::new().set_or_clear_pubsub(Some(PubSub::default()/* use setters */));
    /// let x = NotificationConfig::new().set_or_clear_pubsub(None::<PubSub>);
    /// ```
    pub fn set_or_clear_pubsub<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::notification_config::PubSub>,
    {
        self.pubsub = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NotificationConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NotificationConfig"
    }
}

/// Defines additional types related to [NotificationConfig].
pub mod notification_config {
    #[allow(unused_imports)]
    use super::*;

    /// Pub/Sub specific notification config.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PubSub {
        /// Enable notifications for Pub/Sub.
        pub enabled: bool,

        /// The desired Pub/Sub topic to which notifications will be
        /// sent by GKE. Format is `projects/{project}/topics/{topic}`.
        pub topic: std::string::String,

        /// Allows filtering to one or more specific event types. If no filter is
        /// specified, or if a filter is specified with no event types, all event
        /// types will be sent
        pub filter: std::option::Option<crate::model::notification_config::Filter>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl PubSub {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::notification_config::PubSub::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::notification_config::PubSub;
        /// let x = PubSub::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
            self.enabled = v.into();
            self
        }

        /// Sets the value of [topic][crate::model::notification_config::PubSub::topic].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::notification_config::PubSub;
        /// let x = PubSub::new().set_topic("example");
        /// ```
        pub fn set_topic<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.topic = v.into();
            self
        }

        /// Sets the value of [filter][crate::model::notification_config::PubSub::filter].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::notification_config::PubSub;
        /// use google_cloud_container_v1::model::notification_config::Filter;
        /// let x = PubSub::new().set_filter(Filter::default()/* use setters */);
        /// ```
        pub fn set_filter<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::notification_config::Filter>,
        {
            self.filter = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [filter][crate::model::notification_config::PubSub::filter].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::notification_config::PubSub;
        /// use google_cloud_container_v1::model::notification_config::Filter;
        /// let x = PubSub::new().set_or_clear_filter(Some(Filter::default()/* use setters */));
        /// let x = PubSub::new().set_or_clear_filter(None::<Filter>);
        /// ```
        pub fn set_or_clear_filter<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::notification_config::Filter>,
        {
            self.filter = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for PubSub {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NotificationConfig.PubSub"
        }
    }

    /// Allows filtering to one or more specific event types. If event types are
    /// present, those and only those event types will be transmitted to the
    /// cluster. Other types will be skipped. If no filter is specified, or no
    /// event types are present, all event types will be sent
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct Filter {
        /// Event types to allowlist.
        pub event_type: std::vec::Vec<crate::model::notification_config::EventType>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl Filter {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [event_type][crate::model::notification_config::Filter::event_type].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::notification_config::Filter;
        /// use google_cloud_container_v1::model::notification_config::EventType;
        /// let x = Filter::new().set_event_type([
        ///     EventType::UpgradeAvailableEvent,
        ///     EventType::UpgradeEvent,
        ///     EventType::SecurityBulletinEvent,
        /// ]);
        /// ```
        pub fn set_event_type<T, V>(mut self, v: T) -> Self
        where
            T: std::iter::IntoIterator<Item = V>,
            V: std::convert::Into<crate::model::notification_config::EventType>,
        {
            use std::iter::Iterator;
            self.event_type = v.into_iter().map(|i| i.into()).collect();
            self
        }
    }

    impl wkt::message::Message for Filter {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.NotificationConfig.Filter"
        }
    }

    /// Types of notifications currently supported. Can be used to filter what
    /// notifications are sent.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EventType {
        /// Not set, will be ignored.
        Unspecified,
        /// Corresponds with UpgradeAvailableEvent.
        UpgradeAvailableEvent,
        /// Corresponds with UpgradeEvent.
        UpgradeEvent,
        /// Corresponds with SecurityBulletinEvent.
        SecurityBulletinEvent,
        /// Corresponds with UpgradeInfoEvent.
        UpgradeInfoEvent,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EventType::value] or
        /// [EventType::name].
        UnknownValue(event_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod event_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EventType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::UpgradeAvailableEvent => std::option::Option::Some(1),
                Self::UpgradeEvent => std::option::Option::Some(2),
                Self::SecurityBulletinEvent => std::option::Option::Some(3),
                Self::UpgradeInfoEvent => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EVENT_TYPE_UNSPECIFIED"),
                Self::UpgradeAvailableEvent => std::option::Option::Some("UPGRADE_AVAILABLE_EVENT"),
                Self::UpgradeEvent => std::option::Option::Some("UPGRADE_EVENT"),
                Self::SecurityBulletinEvent => std::option::Option::Some("SECURITY_BULLETIN_EVENT"),
                Self::UpgradeInfoEvent => std::option::Option::Some("UPGRADE_INFO_EVENT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EventType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EventType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EventType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::UpgradeAvailableEvent,
                2 => Self::UpgradeEvent,
                3 => Self::SecurityBulletinEvent,
                4 => Self::UpgradeInfoEvent,
                _ => Self::UnknownValue(event_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EventType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EVENT_TYPE_UNSPECIFIED" => Self::Unspecified,
                "UPGRADE_AVAILABLE_EVENT" => Self::UpgradeAvailableEvent,
                "UPGRADE_EVENT" => Self::UpgradeEvent,
                "SECURITY_BULLETIN_EVENT" => Self::SecurityBulletinEvent,
                "UPGRADE_INFO_EVENT" => Self::UpgradeInfoEvent,
                _ => Self::UnknownValue(event_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EventType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::UpgradeAvailableEvent => serializer.serialize_i32(1),
                Self::UpgradeEvent => serializer.serialize_i32(2),
                Self::SecurityBulletinEvent => serializer.serialize_i32(3),
                Self::UpgradeInfoEvent => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EventType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EventType>::new(
                ".google.container.v1.NotificationConfig.EventType",
            ))
        }
    }
}

/// ConfidentialNodes is configuration for the confidential nodes feature, which
/// makes nodes run on confidential VMs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ConfidentialNodes {
    /// Whether Confidential Nodes feature is enabled.
    pub enabled: bool,

    /// Defines the type of technology used by the confidential node.
    pub confidential_instance_type: crate::model::confidential_nodes::ConfidentialInstanceType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ConfidentialNodes {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ConfidentialNodes::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ConfidentialNodes;
    /// let x = ConfidentialNodes::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [confidential_instance_type][crate::model::ConfidentialNodes::confidential_instance_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ConfidentialNodes;
    /// use google_cloud_container_v1::model::confidential_nodes::ConfidentialInstanceType;
    /// let x0 = ConfidentialNodes::new().set_confidential_instance_type(ConfidentialInstanceType::Sev);
    /// let x1 = ConfidentialNodes::new().set_confidential_instance_type(ConfidentialInstanceType::SevSnp);
    /// let x2 = ConfidentialNodes::new().set_confidential_instance_type(ConfidentialInstanceType::Tdx);
    /// ```
    pub fn set_confidential_instance_type<
        T: std::convert::Into<crate::model::confidential_nodes::ConfidentialInstanceType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.confidential_instance_type = v.into();
        self
    }
}

impl wkt::message::Message for ConfidentialNodes {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ConfidentialNodes"
    }
}

/// Defines additional types related to [ConfidentialNodes].
pub mod confidential_nodes {
    #[allow(unused_imports)]
    use super::*;

    /// The type of technology used by the confidential node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ConfidentialInstanceType {
        /// No type specified. Do not use this value.
        Unspecified,
        /// AMD Secure Encrypted Virtualization.
        Sev,
        /// AMD Secure Encrypted Virtualization - Secure Nested Paging.
        SevSnp,
        /// Intel Trust Domain eXtension.
        Tdx,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ConfidentialInstanceType::value] or
        /// [ConfidentialInstanceType::name].
        UnknownValue(confidential_instance_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod confidential_instance_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ConfidentialInstanceType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Sev => std::option::Option::Some(1),
                Self::SevSnp => std::option::Option::Some(2),
                Self::Tdx => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("CONFIDENTIAL_INSTANCE_TYPE_UNSPECIFIED")
                }
                Self::Sev => std::option::Option::Some("SEV"),
                Self::SevSnp => std::option::Option::Some("SEV_SNP"),
                Self::Tdx => std::option::Option::Some("TDX"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ConfidentialInstanceType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ConfidentialInstanceType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ConfidentialInstanceType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Sev,
                2 => Self::SevSnp,
                3 => Self::Tdx,
                _ => Self::UnknownValue(confidential_instance_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ConfidentialInstanceType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CONFIDENTIAL_INSTANCE_TYPE_UNSPECIFIED" => Self::Unspecified,
                "SEV" => Self::Sev,
                "SEV_SNP" => Self::SevSnp,
                "TDX" => Self::Tdx,
                _ => Self::UnknownValue(confidential_instance_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ConfidentialInstanceType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Sev => serializer.serialize_i32(1),
                Self::SevSnp => serializer.serialize_i32(2),
                Self::Tdx => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ConfidentialInstanceType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<ConfidentialInstanceType>::new(
                    ".google.container.v1.ConfidentialNodes.ConfidentialInstanceType",
                ),
            )
        }
    }
}

/// UpgradeEvent is a notification sent to customers by the cluster server when
/// a resource is upgrading.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpgradeEvent {
    /// The resource type that is upgrading.
    pub resource_type: crate::model::UpgradeResourceType,

    /// The operation associated with this upgrade.
    pub operation: std::string::String,

    /// The time when the operation was started.
    pub operation_start_time: std::option::Option<wkt::Timestamp>,

    /// The current version before the upgrade.
    pub current_version: std::string::String,

    /// The target version for the upgrade.
    pub target_version: std::string::String,

    /// Optional relative path to the resource. For example in node pool upgrades,
    /// the relative path of the node pool.
    pub resource: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpgradeEvent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource_type][crate::model::UpgradeEvent::resource_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// use google_cloud_container_v1::model::UpgradeResourceType;
    /// let x0 = UpgradeEvent::new().set_resource_type(UpgradeResourceType::Master);
    /// let x1 = UpgradeEvent::new().set_resource_type(UpgradeResourceType::NodePool);
    /// ```
    pub fn set_resource_type<T: std::convert::Into<crate::model::UpgradeResourceType>>(
        mut self,
        v: T,
    ) -> Self {
        self.resource_type = v.into();
        self
    }

    /// Sets the value of [operation][crate::model::UpgradeEvent::operation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// let x = UpgradeEvent::new().set_operation("example");
    /// ```
    pub fn set_operation<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.operation = v.into();
        self
    }

    /// Sets the value of [operation_start_time][crate::model::UpgradeEvent::operation_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeEvent::new().set_operation_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_operation_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.operation_start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [operation_start_time][crate::model::UpgradeEvent::operation_start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeEvent::new().set_or_clear_operation_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeEvent::new().set_or_clear_operation_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_operation_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.operation_start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [current_version][crate::model::UpgradeEvent::current_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// let x = UpgradeEvent::new().set_current_version("example");
    /// ```
    pub fn set_current_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.current_version = v.into();
        self
    }

    /// Sets the value of [target_version][crate::model::UpgradeEvent::target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// let x = UpgradeEvent::new().set_target_version("example");
    /// ```
    pub fn set_target_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_version = v.into();
        self
    }

    /// Sets the value of [resource][crate::model::UpgradeEvent::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeEvent;
    /// let x = UpgradeEvent::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }
}

impl wkt::message::Message for UpgradeEvent {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpgradeEvent"
    }
}

/// UpgradeInfoEvent is a notification sent to customers about the upgrade
/// information of a resource.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpgradeInfoEvent {
    /// The resource type associated with the upgrade.
    pub resource_type: crate::model::UpgradeResourceType,

    /// The operation associated with this upgrade.
    pub operation: std::string::String,

    /// The time when the operation was started.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// The time when the operation ended.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// The current version before the upgrade.
    pub current_version: std::string::String,

    /// The target version for the upgrade.
    pub target_version: std::string::String,

    /// Optional relative path to the resource. For example in node pool upgrades,
    /// the relative path of the node pool.
    pub resource: std::string::String,

    /// Output only. The state of the upgrade.
    pub state: crate::model::upgrade_info_event::State,

    /// The end of standard support timestamp.
    pub standard_support_end_time: std::option::Option<wkt::Timestamp>,

    /// The end of extended support timestamp.
    pub extended_support_end_time: std::option::Option<wkt::Timestamp>,

    /// A brief description of the event.
    pub description: std::string::String,

    /// The type of the event.
    pub event_type: crate::model::upgrade_info_event::EventType,

    /// The information about the disruption event. This field is only populated
    /// when event_type is DISRUPTION_EVENT.
    pub disruption_event: std::option::Option<crate::model::DisruptionEvent>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpgradeInfoEvent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource_type][crate::model::UpgradeInfoEvent::resource_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use google_cloud_container_v1::model::UpgradeResourceType;
    /// let x0 = UpgradeInfoEvent::new().set_resource_type(UpgradeResourceType::Master);
    /// let x1 = UpgradeInfoEvent::new().set_resource_type(UpgradeResourceType::NodePool);
    /// ```
    pub fn set_resource_type<T: std::convert::Into<crate::model::UpgradeResourceType>>(
        mut self,
        v: T,
    ) -> Self {
        self.resource_type = v.into();
        self
    }

    /// Sets the value of [operation][crate::model::UpgradeInfoEvent::operation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// let x = UpgradeInfoEvent::new().set_operation("example");
    /// ```
    pub fn set_operation<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.operation = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::UpgradeInfoEvent::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_time][crate::model::UpgradeInfoEvent::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_or_clear_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeInfoEvent::new().set_or_clear_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::UpgradeInfoEvent::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::UpgradeInfoEvent::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeInfoEvent::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [current_version][crate::model::UpgradeInfoEvent::current_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// let x = UpgradeInfoEvent::new().set_current_version("example");
    /// ```
    pub fn set_current_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.current_version = v.into();
        self
    }

    /// Sets the value of [target_version][crate::model::UpgradeInfoEvent::target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// let x = UpgradeInfoEvent::new().set_target_version("example");
    /// ```
    pub fn set_target_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_version = v.into();
        self
    }

    /// Sets the value of [resource][crate::model::UpgradeInfoEvent::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// let x = UpgradeInfoEvent::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }

    /// Sets the value of [state][crate::model::UpgradeInfoEvent::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use google_cloud_container_v1::model::upgrade_info_event::State;
    /// let x0 = UpgradeInfoEvent::new().set_state(State::Scheduled);
    /// let x1 = UpgradeInfoEvent::new().set_state(State::Started);
    /// let x2 = UpgradeInfoEvent::new().set_state(State::Succeeded);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::upgrade_info_event::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [standard_support_end_time][crate::model::UpgradeInfoEvent::standard_support_end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_standard_support_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_standard_support_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.standard_support_end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [standard_support_end_time][crate::model::UpgradeInfoEvent::standard_support_end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_or_clear_standard_support_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeInfoEvent::new().set_or_clear_standard_support_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_standard_support_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.standard_support_end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [extended_support_end_time][crate::model::UpgradeInfoEvent::extended_support_end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_extended_support_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_extended_support_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.extended_support_end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [extended_support_end_time][crate::model::UpgradeInfoEvent::extended_support_end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use wkt::Timestamp;
    /// let x = UpgradeInfoEvent::new().set_or_clear_extended_support_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeInfoEvent::new().set_or_clear_extended_support_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_extended_support_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.extended_support_end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [description][crate::model::UpgradeInfoEvent::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// let x = UpgradeInfoEvent::new().set_description("example");
    /// ```
    pub fn set_description<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.description = v.into();
        self
    }

    /// Sets the value of [event_type][crate::model::UpgradeInfoEvent::event_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use google_cloud_container_v1::model::upgrade_info_event::EventType;
    /// let x0 = UpgradeInfoEvent::new().set_event_type(EventType::EndOfSupport);
    /// let x1 = UpgradeInfoEvent::new().set_event_type(EventType::CosMilestoneVersionUpdate);
    /// let x2 = UpgradeInfoEvent::new().set_event_type(EventType::UpgradeLifecycle);
    /// ```
    pub fn set_event_type<T: std::convert::Into<crate::model::upgrade_info_event::EventType>>(
        mut self,
        v: T,
    ) -> Self {
        self.event_type = v.into();
        self
    }

    /// Sets the value of [disruption_event][crate::model::UpgradeInfoEvent::disruption_event].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use google_cloud_container_v1::model::DisruptionEvent;
    /// let x = UpgradeInfoEvent::new().set_disruption_event(DisruptionEvent::default()/* use setters */);
    /// ```
    pub fn set_disruption_event<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::DisruptionEvent>,
    {
        self.disruption_event = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [disruption_event][crate::model::UpgradeInfoEvent::disruption_event].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeInfoEvent;
    /// use google_cloud_container_v1::model::DisruptionEvent;
    /// let x = UpgradeInfoEvent::new().set_or_clear_disruption_event(Some(DisruptionEvent::default()/* use setters */));
    /// let x = UpgradeInfoEvent::new().set_or_clear_disruption_event(None::<DisruptionEvent>);
    /// ```
    pub fn set_or_clear_disruption_event<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::DisruptionEvent>,
    {
        self.disruption_event = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for UpgradeInfoEvent {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpgradeInfoEvent"
    }
}

/// Defines additional types related to [UpgradeInfoEvent].
pub mod upgrade_info_event {
    #[allow(unused_imports)]
    use super::*;

    /// The state of the upgrade.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// STATE_UNSPECIFIED indicates the state is unspecified.
        Unspecified,
        /// SCHEDULED indicates the upgrade was scheduled.
        Scheduled,
        /// STARTED indicates the upgrade has started.
        Started,
        /// SUCCEEDED indicates the upgrade has completed successfully.
        Succeeded,
        /// FAILED indicates the upgrade has failed.
        Failed,
        /// CANCELED indicates the upgrade has canceled.
        Canceled,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl State {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Scheduled => std::option::Option::Some(1),
                Self::Started => std::option::Option::Some(3),
                Self::Succeeded => std::option::Option::Some(4),
                Self::Failed => std::option::Option::Some(5),
                Self::Canceled => std::option::Option::Some(6),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATE_UNSPECIFIED"),
                Self::Scheduled => std::option::Option::Some("SCHEDULED"),
                Self::Started => std::option::Option::Some("STARTED"),
                Self::Succeeded => std::option::Option::Some("SUCCEEDED"),
                Self::Failed => std::option::Option::Some("FAILED"),
                Self::Canceled => std::option::Option::Some("CANCELED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for State {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for State {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Scheduled,
                3 => Self::Started,
                4 => Self::Succeeded,
                5 => Self::Failed,
                6 => Self::Canceled,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATE_UNSPECIFIED" => Self::Unspecified,
                "SCHEDULED" => Self::Scheduled,
                "STARTED" => Self::Started,
                "SUCCEEDED" => Self::Succeeded,
                "FAILED" => Self::Failed,
                "CANCELED" => Self::Canceled,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Scheduled => serializer.serialize_i32(1),
                Self::Started => serializer.serialize_i32(3),
                Self::Succeeded => serializer.serialize_i32(4),
                Self::Failed => serializer.serialize_i32(5),
                Self::Canceled => serializer.serialize_i32(6),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for State {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<State>::new(
                ".google.container.v1.UpgradeInfoEvent.State",
            ))
        }
    }

    /// The type of the event.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum EventType {
        /// EVENT_TYPE_UNSPECIFIED indicates the event type is unspecified.
        Unspecified,
        /// END_OF_SUPPORT indicates GKE version reaches end of support, check
        /// standard_support_end_time and extended_support_end_time for more details.
        EndOfSupport,
        /// COS_MILESTONE_VERSION_UPDATE indicates that the COS node image will
        /// update COS milestone version for new patch versions starting with
        /// the one in the description.
        CosMilestoneVersionUpdate,
        /// UPGRADE_LIFECYCLE indicates the event is about the upgrade lifecycle.
        UpgradeLifecycle,
        /// DISRUPTION_EVENT indicates the event is about the disruption.
        DisruptionEvent,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [EventType::value] or
        /// [EventType::name].
        UnknownValue(event_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod event_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl EventType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::EndOfSupport => std::option::Option::Some(1),
                Self::CosMilestoneVersionUpdate => std::option::Option::Some(2),
                Self::UpgradeLifecycle => std::option::Option::Some(3),
                Self::DisruptionEvent => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("EVENT_TYPE_UNSPECIFIED"),
                Self::EndOfSupport => std::option::Option::Some("END_OF_SUPPORT"),
                Self::CosMilestoneVersionUpdate => {
                    std::option::Option::Some("COS_MILESTONE_VERSION_UPDATE")
                }
                Self::UpgradeLifecycle => std::option::Option::Some("UPGRADE_LIFECYCLE"),
                Self::DisruptionEvent => std::option::Option::Some("DISRUPTION_EVENT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for EventType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for EventType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for EventType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::EndOfSupport,
                2 => Self::CosMilestoneVersionUpdate,
                3 => Self::UpgradeLifecycle,
                4 => Self::DisruptionEvent,
                _ => Self::UnknownValue(event_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for EventType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "EVENT_TYPE_UNSPECIFIED" => Self::Unspecified,
                "END_OF_SUPPORT" => Self::EndOfSupport,
                "COS_MILESTONE_VERSION_UPDATE" => Self::CosMilestoneVersionUpdate,
                "UPGRADE_LIFECYCLE" => Self::UpgradeLifecycle,
                "DISRUPTION_EVENT" => Self::DisruptionEvent,
                _ => Self::UnknownValue(event_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for EventType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::EndOfSupport => serializer.serialize_i32(1),
                Self::CosMilestoneVersionUpdate => serializer.serialize_i32(2),
                Self::UpgradeLifecycle => serializer.serialize_i32(3),
                Self::DisruptionEvent => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for EventType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<EventType>::new(
                ".google.container.v1.UpgradeInfoEvent.EventType",
            ))
        }
    }
}

/// DisruptionEvent is a notification sent to customers about the disruption
/// event of a resource.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DisruptionEvent {
    /// The type of the disruption event.
    pub disruption_type: crate::model::disruption_event::DisruptionType,

    /// The node whose drain is blocked by PDB. This field is set for both
    /// POD_PDB_VIOLATION and POD_NOT_ENOUGH_PDB event.
    pub pdb_blocked_node: std::string::String,

    /// The pods whose evictions are blocked by PDB. This field is set for
    /// both POD_PDB_VIOLATION and POD_NOT_ENOUGH_PDB event.
    pub pdb_blocked_pod: std::vec::Vec<crate::model::disruption_event::PdbBlockedPod>,

    /// The timeout in seconds for which the node drain is blocked by PDB.
    /// After this timeout, pods are forcefully evicted.
    /// This field is only populated when event_type is
    /// POD_PDB_VIOLATION.
    pub pdb_violation_timeout: std::option::Option<wkt::Duration>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DisruptionEvent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disruption_type][crate::model::DisruptionEvent::disruption_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionEvent;
    /// use google_cloud_container_v1::model::disruption_event::DisruptionType;
    /// let x0 = DisruptionEvent::new().set_disruption_type(DisruptionType::PodNotEnoughPdb);
    /// let x1 = DisruptionEvent::new().set_disruption_type(DisruptionType::PodPdbViolation);
    /// ```
    pub fn set_disruption_type<
        T: std::convert::Into<crate::model::disruption_event::DisruptionType>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.disruption_type = v.into();
        self
    }

    /// Sets the value of [pdb_blocked_node][crate::model::DisruptionEvent::pdb_blocked_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionEvent;
    /// let x = DisruptionEvent::new().set_pdb_blocked_node("example");
    /// ```
    pub fn set_pdb_blocked_node<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.pdb_blocked_node = v.into();
        self
    }

    /// Sets the value of [pdb_blocked_pod][crate::model::DisruptionEvent::pdb_blocked_pod].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionEvent;
    /// use google_cloud_container_v1::model::disruption_event::PdbBlockedPod;
    /// let x = DisruptionEvent::new()
    ///     .set_pdb_blocked_pod([
    ///         PdbBlockedPod::default()/* use setters */,
    ///         PdbBlockedPod::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_pdb_blocked_pod<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::disruption_event::PdbBlockedPod>,
    {
        use std::iter::Iterator;
        self.pdb_blocked_pod = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [pdb_violation_timeout][crate::model::DisruptionEvent::pdb_violation_timeout].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionEvent;
    /// use wkt::Duration;
    /// let x = DisruptionEvent::new().set_pdb_violation_timeout(Duration::default()/* use setters */);
    /// ```
    pub fn set_pdb_violation_timeout<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.pdb_violation_timeout = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [pdb_violation_timeout][crate::model::DisruptionEvent::pdb_violation_timeout].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DisruptionEvent;
    /// use wkt::Duration;
    /// let x = DisruptionEvent::new().set_or_clear_pdb_violation_timeout(Some(Duration::default()/* use setters */));
    /// let x = DisruptionEvent::new().set_or_clear_pdb_violation_timeout(None::<Duration>);
    /// ```
    pub fn set_or_clear_pdb_violation_timeout<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Duration>,
    {
        self.pdb_violation_timeout = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for DisruptionEvent {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DisruptionEvent"
    }
}

/// Defines additional types related to [DisruptionEvent].
pub mod disruption_event {
    #[allow(unused_imports)]
    use super::*;

    /// The namespace/name of the pod whose eviction is blocked by PDB.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct PdbBlockedPod {
        /// The namespace of the pod.
        pub namespace: std::string::String,

        /// The name of the pod.
        pub name: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl PdbBlockedPod {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [namespace][crate::model::disruption_event::PdbBlockedPod::namespace].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::disruption_event::PdbBlockedPod;
        /// let x = PdbBlockedPod::new().set_namespace("example");
        /// ```
        pub fn set_namespace<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.namespace = v.into();
            self
        }

        /// Sets the value of [name][crate::model::disruption_event::PdbBlockedPod::name].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::disruption_event::PdbBlockedPod;
        /// let x = PdbBlockedPod::new().set_name("example");
        /// ```
        pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.name = v.into();
            self
        }
    }

    impl wkt::message::Message for PdbBlockedPod {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.DisruptionEvent.PdbBlockedPod"
        }
    }

    /// The type of the disruption event.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum DisruptionType {
        /// DISRUPTION_TYPE_UNSPECIFIED indicates the disruption type is unspecified.
        Unspecified,
        /// POD_NOT_ENOUGH_PDB indicates there are still running pods
        /// on the node during node drain because their evictions are blocked by PDB.
        PodNotEnoughPdb,
        /// POD_PDB_VIOLATION indicates that there are force pod
        /// evictions during node drain which violate the PDB.
        PodPdbViolation,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [DisruptionType::value] or
        /// [DisruptionType::name].
        UnknownValue(disruption_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod disruption_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl DisruptionType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::PodNotEnoughPdb => std::option::Option::Some(1),
                Self::PodPdbViolation => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("DISRUPTION_TYPE_UNSPECIFIED"),
                Self::PodNotEnoughPdb => std::option::Option::Some("POD_NOT_ENOUGH_PDB"),
                Self::PodPdbViolation => std::option::Option::Some("POD_PDB_VIOLATION"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for DisruptionType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for DisruptionType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for DisruptionType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::PodNotEnoughPdb,
                2 => Self::PodPdbViolation,
                _ => Self::UnknownValue(disruption_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for DisruptionType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "DISRUPTION_TYPE_UNSPECIFIED" => Self::Unspecified,
                "POD_NOT_ENOUGH_PDB" => Self::PodNotEnoughPdb,
                "POD_PDB_VIOLATION" => Self::PodPdbViolation,
                _ => Self::UnknownValue(disruption_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for DisruptionType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::PodNotEnoughPdb => serializer.serialize_i32(1),
                Self::PodPdbViolation => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for DisruptionType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<DisruptionType>::new(
                ".google.container.v1.DisruptionEvent.DisruptionType",
            ))
        }
    }
}

/// UpgradeAvailableEvent is a notification sent to customers when a new
/// available version is released.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpgradeAvailableEvent {
    /// The release version available for upgrade.
    pub version: std::string::String,

    /// The resource type of the release version.
    pub resource_type: crate::model::UpgradeResourceType,

    /// The release channel of the version. If empty, it means a non-channel
    /// release.
    pub release_channel: std::option::Option<crate::model::ReleaseChannel>,

    /// Optional relative path to the resource. For example, the relative path of
    /// the node pool.
    pub resource: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpgradeAvailableEvent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::UpgradeAvailableEvent::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeAvailableEvent;
    /// let x = UpgradeAvailableEvent::new().set_version("example");
    /// ```
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }

    /// Sets the value of [resource_type][crate::model::UpgradeAvailableEvent::resource_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeAvailableEvent;
    /// use google_cloud_container_v1::model::UpgradeResourceType;
    /// let x0 = UpgradeAvailableEvent::new().set_resource_type(UpgradeResourceType::Master);
    /// let x1 = UpgradeAvailableEvent::new().set_resource_type(UpgradeResourceType::NodePool);
    /// ```
    pub fn set_resource_type<T: std::convert::Into<crate::model::UpgradeResourceType>>(
        mut self,
        v: T,
    ) -> Self {
        self.resource_type = v.into();
        self
    }

    /// Sets the value of [release_channel][crate::model::UpgradeAvailableEvent::release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeAvailableEvent;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = UpgradeAvailableEvent::new().set_release_channel(ReleaseChannel::default()/* use setters */);
    /// ```
    pub fn set_release_channel<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.release_channel = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [release_channel][crate::model::UpgradeAvailableEvent::release_channel].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeAvailableEvent;
    /// use google_cloud_container_v1::model::ReleaseChannel;
    /// let x = UpgradeAvailableEvent::new().set_or_clear_release_channel(Some(ReleaseChannel::default()/* use setters */));
    /// let x = UpgradeAvailableEvent::new().set_or_clear_release_channel(None::<ReleaseChannel>);
    /// ```
    pub fn set_or_clear_release_channel<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ReleaseChannel>,
    {
        self.release_channel = v.map(|x| x.into());
        self
    }

    /// Sets the value of [resource][crate::model::UpgradeAvailableEvent::resource].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeAvailableEvent;
    /// let x = UpgradeAvailableEvent::new().set_resource("example");
    /// ```
    pub fn set_resource<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.resource = v.into();
        self
    }
}

impl wkt::message::Message for UpgradeAvailableEvent {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpgradeAvailableEvent"
    }
}

/// SecurityBulletinEvent is a notification sent to customers when a security
/// bulletin has been posted that they are vulnerable to.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecurityBulletinEvent {
    /// The resource type (node/control plane) that has the vulnerability. Multiple
    /// notifications (1 notification per resource type) will be sent for a
    /// vulnerability that affects > 1 resource type.
    pub resource_type_affected: std::string::String,

    /// The ID of the bulletin corresponding to the vulnerability.
    pub bulletin_id: std::string::String,

    /// The CVEs associated with this bulletin.
    pub cve_ids: std::vec::Vec<std::string::String>,

    /// The severity of this bulletin as it relates to GKE.
    pub severity: std::string::String,

    /// The URI link to the bulletin on the website for more information.
    pub bulletin_uri: std::string::String,

    /// A brief description of the bulletin. See the bulletin pointed to by the
    /// bulletin_uri field for an expanded description.
    pub brief_description: std::string::String,

    /// The GKE minor versions affected by this vulnerability.
    pub affected_supported_minors: std::vec::Vec<std::string::String>,

    /// The GKE versions where this vulnerability is patched.
    pub patched_versions: std::vec::Vec<std::string::String>,

    /// This represents a version selected from the patched_versions field that
    /// the cluster receiving this notification should most likely want to upgrade
    /// to based on its current version. Note that if this notification is being
    /// received by a given cluster, it means that this version is currently
    /// available as an upgrade target in that cluster's location.
    pub suggested_upgrade_target: std::string::String,

    /// If this field is specified, it means there are manual steps that the user
    /// must take to make their clusters safe.
    pub manual_steps_required: bool,

    /// The GKE versions where this vulnerability is mitigated.
    pub mitigated_versions: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecurityBulletinEvent {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [resource_type_affected][crate::model::SecurityBulletinEvent::resource_type_affected].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_resource_type_affected("example");
    /// ```
    pub fn set_resource_type_affected<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.resource_type_affected = v.into();
        self
    }

    /// Sets the value of [bulletin_id][crate::model::SecurityBulletinEvent::bulletin_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_bulletin_id("example");
    /// ```
    pub fn set_bulletin_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.bulletin_id = v.into();
        self
    }

    /// Sets the value of [cve_ids][crate::model::SecurityBulletinEvent::cve_ids].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_cve_ids(["a", "b", "c"]);
    /// ```
    pub fn set_cve_ids<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.cve_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [severity][crate::model::SecurityBulletinEvent::severity].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_severity("example");
    /// ```
    pub fn set_severity<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.severity = v.into();
        self
    }

    /// Sets the value of [bulletin_uri][crate::model::SecurityBulletinEvent::bulletin_uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_bulletin_uri("example");
    /// ```
    pub fn set_bulletin_uri<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.bulletin_uri = v.into();
        self
    }

    /// Sets the value of [brief_description][crate::model::SecurityBulletinEvent::brief_description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_brief_description("example");
    /// ```
    pub fn set_brief_description<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.brief_description = v.into();
        self
    }

    /// Sets the value of [affected_supported_minors][crate::model::SecurityBulletinEvent::affected_supported_minors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_affected_supported_minors(["a", "b", "c"]);
    /// ```
    pub fn set_affected_supported_minors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.affected_supported_minors = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [patched_versions][crate::model::SecurityBulletinEvent::patched_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_patched_versions(["a", "b", "c"]);
    /// ```
    pub fn set_patched_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.patched_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [suggested_upgrade_target][crate::model::SecurityBulletinEvent::suggested_upgrade_target].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_suggested_upgrade_target("example");
    /// ```
    pub fn set_suggested_upgrade_target<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.suggested_upgrade_target = v.into();
        self
    }

    /// Sets the value of [manual_steps_required][crate::model::SecurityBulletinEvent::manual_steps_required].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_manual_steps_required(true);
    /// ```
    pub fn set_manual_steps_required<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.manual_steps_required = v.into();
        self
    }

    /// Sets the value of [mitigated_versions][crate::model::SecurityBulletinEvent::mitigated_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecurityBulletinEvent;
    /// let x = SecurityBulletinEvent::new().set_mitigated_versions(["a", "b", "c"]);
    /// ```
    pub fn set_mitigated_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.mitigated_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for SecurityBulletinEvent {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecurityBulletinEvent"
    }
}

/// Autopilot is the configuration for Autopilot settings on the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Autopilot {
    /// Enable Autopilot
    pub enabled: bool,

    /// WorkloadPolicyConfig is the configuration related to GCW workload policy
    pub workload_policy_config: std::option::Option<crate::model::WorkloadPolicyConfig>,

    /// PrivilegedAdmissionConfig is the configuration related to privileged
    /// admission control.
    pub privileged_admission_config: std::option::Option<crate::model::PrivilegedAdmissionConfig>,

    /// ClusterPolicyConfig denotes cluster level policies that are enforced for
    /// the cluster.
    pub cluster_policy_config: std::option::Option<crate::model::ClusterPolicyConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Autopilot {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::Autopilot::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// let x = Autopilot::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [workload_policy_config][crate::model::Autopilot::workload_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = Autopilot::new().set_workload_policy_config(WorkloadPolicyConfig::default()/* use setters */);
    /// ```
    pub fn set_workload_policy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadPolicyConfig>,
    {
        self.workload_policy_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [workload_policy_config][crate::model::Autopilot::workload_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = Autopilot::new().set_or_clear_workload_policy_config(Some(WorkloadPolicyConfig::default()/* use setters */));
    /// let x = Autopilot::new().set_or_clear_workload_policy_config(None::<WorkloadPolicyConfig>);
    /// ```
    pub fn set_or_clear_workload_policy_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::WorkloadPolicyConfig>,
    {
        self.workload_policy_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [privileged_admission_config][crate::model::Autopilot::privileged_admission_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::PrivilegedAdmissionConfig;
    /// let x = Autopilot::new().set_privileged_admission_config(PrivilegedAdmissionConfig::default()/* use setters */);
    /// ```
    pub fn set_privileged_admission_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::PrivilegedAdmissionConfig>,
    {
        self.privileged_admission_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [privileged_admission_config][crate::model::Autopilot::privileged_admission_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::PrivilegedAdmissionConfig;
    /// let x = Autopilot::new().set_or_clear_privileged_admission_config(Some(PrivilegedAdmissionConfig::default()/* use setters */));
    /// let x = Autopilot::new().set_or_clear_privileged_admission_config(None::<PrivilegedAdmissionConfig>);
    /// ```
    pub fn set_or_clear_privileged_admission_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::PrivilegedAdmissionConfig>,
    {
        self.privileged_admission_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [cluster_policy_config][crate::model::Autopilot::cluster_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = Autopilot::new().set_cluster_policy_config(ClusterPolicyConfig::default()/* use setters */);
    /// ```
    pub fn set_cluster_policy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ClusterPolicyConfig>,
    {
        self.cluster_policy_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [cluster_policy_config][crate::model::Autopilot::cluster_policy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Autopilot;
    /// use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = Autopilot::new().set_or_clear_cluster_policy_config(Some(ClusterPolicyConfig::default()/* use setters */));
    /// let x = Autopilot::new().set_or_clear_cluster_policy_config(None::<ClusterPolicyConfig>);
    /// ```
    pub fn set_or_clear_cluster_policy_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ClusterPolicyConfig>,
    {
        self.cluster_policy_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for Autopilot {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.Autopilot"
    }
}

/// ClusterPolicyConfig stores the configuration for cluster wide policies.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClusterPolicyConfig {
    /// Denotes that preventing creation and mutation of resources in GKE
    /// managed namespaces and cluster-scoped GKE managed resources .
    pub no_system_mutation: std::option::Option<bool>,

    /// Denotes preventing impersonation and CSRs for GKE System users.
    pub no_system_impersonation: std::option::Option<bool>,

    /// Denotes preventing unsafe webhooks.
    pub no_unsafe_webhooks: std::option::Option<bool>,

    /// Denotes preventing standard node pools and requiring only autopilot node
    /// pools.
    pub no_standard_node_pools: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ClusterPolicyConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [no_system_mutation][crate::model::ClusterPolicyConfig::no_system_mutation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_no_system_mutation(true);
    /// ```
    pub fn set_no_system_mutation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_system_mutation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [no_system_mutation][crate::model::ClusterPolicyConfig::no_system_mutation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_system_mutation(Some(false));
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_system_mutation(None::<bool>);
    /// ```
    pub fn set_or_clear_no_system_mutation<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_system_mutation = v.map(|x| x.into());
        self
    }

    /// Sets the value of [no_system_impersonation][crate::model::ClusterPolicyConfig::no_system_impersonation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_no_system_impersonation(true);
    /// ```
    pub fn set_no_system_impersonation<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_system_impersonation = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [no_system_impersonation][crate::model::ClusterPolicyConfig::no_system_impersonation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_system_impersonation(Some(false));
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_system_impersonation(None::<bool>);
    /// ```
    pub fn set_or_clear_no_system_impersonation<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_system_impersonation = v.map(|x| x.into());
        self
    }

    /// Sets the value of [no_unsafe_webhooks][crate::model::ClusterPolicyConfig::no_unsafe_webhooks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_no_unsafe_webhooks(true);
    /// ```
    pub fn set_no_unsafe_webhooks<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_unsafe_webhooks = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [no_unsafe_webhooks][crate::model::ClusterPolicyConfig::no_unsafe_webhooks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_unsafe_webhooks(Some(false));
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_unsafe_webhooks(None::<bool>);
    /// ```
    pub fn set_or_clear_no_unsafe_webhooks<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_unsafe_webhooks = v.map(|x| x.into());
        self
    }

    /// Sets the value of [no_standard_node_pools][crate::model::ClusterPolicyConfig::no_standard_node_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_no_standard_node_pools(true);
    /// ```
    pub fn set_no_standard_node_pools<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_standard_node_pools = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [no_standard_node_pools][crate::model::ClusterPolicyConfig::no_standard_node_pools].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterPolicyConfig;
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_standard_node_pools(Some(false));
    /// let x = ClusterPolicyConfig::new().set_or_clear_no_standard_node_pools(None::<bool>);
    /// ```
    pub fn set_or_clear_no_standard_node_pools<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.no_standard_node_pools = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ClusterPolicyConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ClusterPolicyConfig"
    }
}

/// PrivilegedAdmissionConfig stores the list of authorized allowlist
/// paths for the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PrivilegedAdmissionConfig {
    /// The customer allowlist Cloud Storage paths for the cluster. These paths are
    /// used with the `--autopilot-privileged-admission` flag to authorize
    /// privileged workloads in Autopilot clusters.
    ///
    /// Paths can be GKE-owned, in the format
    /// `gke://<partner_name>/<app_name>/<allowlist_path>`, or customer-owned, in
    /// the format `gs://<bucket_name>/<allowlist_path>`.
    ///
    /// Wildcards (`*`) are supported to authorize all allowlists under specific
    /// paths or directories. Example: `gs://my-bucket/*` will authorize all
    /// allowlists under the `my-bucket` bucket.
    pub allowlist_paths: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PrivilegedAdmissionConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [allowlist_paths][crate::model::PrivilegedAdmissionConfig::allowlist_paths].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PrivilegedAdmissionConfig;
    /// let x = PrivilegedAdmissionConfig::new().set_allowlist_paths(["a", "b", "c"]);
    /// ```
    pub fn set_allowlist_paths<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.allowlist_paths = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for PrivilegedAdmissionConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PrivilegedAdmissionConfig"
    }
}

/// WorkloadPolicyConfig is the configuration related to GCW workload policy
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkloadPolicyConfig {
    /// If true, workloads can use NET_ADMIN capability.
    pub allow_net_admin: std::option::Option<bool>,

    /// If true, enables the GCW Auditor that audits workloads on
    /// standard clusters.
    pub autopilot_compatibility_auditing_enabled: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl WorkloadPolicyConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [allow_net_admin][crate::model::WorkloadPolicyConfig::allow_net_admin].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = WorkloadPolicyConfig::new().set_allow_net_admin(true);
    /// ```
    pub fn set_allow_net_admin<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.allow_net_admin = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [allow_net_admin][crate::model::WorkloadPolicyConfig::allow_net_admin].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = WorkloadPolicyConfig::new().set_or_clear_allow_net_admin(Some(false));
    /// let x = WorkloadPolicyConfig::new().set_or_clear_allow_net_admin(None::<bool>);
    /// ```
    pub fn set_or_clear_allow_net_admin<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.allow_net_admin = v.map(|x| x.into());
        self
    }

    /// Sets the value of [autopilot_compatibility_auditing_enabled][crate::model::WorkloadPolicyConfig::autopilot_compatibility_auditing_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = WorkloadPolicyConfig::new().set_autopilot_compatibility_auditing_enabled(true);
    /// ```
    pub fn set_autopilot_compatibility_auditing_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.autopilot_compatibility_auditing_enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [autopilot_compatibility_auditing_enabled][crate::model::WorkloadPolicyConfig::autopilot_compatibility_auditing_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::WorkloadPolicyConfig;
    /// let x = WorkloadPolicyConfig::new().set_or_clear_autopilot_compatibility_auditing_enabled(Some(false));
    /// let x = WorkloadPolicyConfig::new().set_or_clear_autopilot_compatibility_auditing_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_autopilot_compatibility_auditing_enabled<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.autopilot_compatibility_auditing_enabled = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for WorkloadPolicyConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.WorkloadPolicyConfig"
    }
}

/// LoggingConfig is cluster logging configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LoggingConfig {
    /// Logging components configuration
    pub component_config: std::option::Option<crate::model::LoggingComponentConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LoggingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [component_config][crate::model::LoggingConfig::component_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LoggingConfig;
    /// use google_cloud_container_v1::model::LoggingComponentConfig;
    /// let x = LoggingConfig::new().set_component_config(LoggingComponentConfig::default()/* use setters */);
    /// ```
    pub fn set_component_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LoggingComponentConfig>,
    {
        self.component_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [component_config][crate::model::LoggingConfig::component_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LoggingConfig;
    /// use google_cloud_container_v1::model::LoggingComponentConfig;
    /// let x = LoggingConfig::new().set_or_clear_component_config(Some(LoggingComponentConfig::default()/* use setters */));
    /// let x = LoggingConfig::new().set_or_clear_component_config(None::<LoggingComponentConfig>);
    /// ```
    pub fn set_or_clear_component_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LoggingComponentConfig>,
    {
        self.component_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for LoggingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LoggingConfig"
    }
}

/// LoggingComponentConfig is cluster logging component configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LoggingComponentConfig {
    /// Select components to collect logs. An empty set would disable all logging.
    pub enable_components: std::vec::Vec<crate::model::logging_component_config::Component>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LoggingComponentConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_components][crate::model::LoggingComponentConfig::enable_components].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LoggingComponentConfig;
    /// use google_cloud_container_v1::model::logging_component_config::Component;
    /// let x = LoggingComponentConfig::new().set_enable_components([
    ///     Component::SystemComponents,
    ///     Component::Workloads,
    ///     Component::Apiserver,
    /// ]);
    /// ```
    pub fn set_enable_components<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::logging_component_config::Component>,
    {
        use std::iter::Iterator;
        self.enable_components = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for LoggingComponentConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LoggingComponentConfig"
    }
}

/// Defines additional types related to [LoggingComponentConfig].
pub mod logging_component_config {
    #[allow(unused_imports)]
    use super::*;

    /// GKE components exposing logs
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Component {
        /// Default value. This shouldn't be used.
        Unspecified,
        /// system components
        SystemComponents,
        /// workloads
        Workloads,
        /// kube-apiserver
        Apiserver,
        /// kube-scheduler
        Scheduler,
        /// kube-controller-manager
        ControllerManager,
        /// kcp-sshd
        KcpSshd,
        /// kcp connection logs
        KcpConnection,
        /// horizontal pod autoscaler decision logs
        KcpHpa,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Component::value] or
        /// [Component::name].
        UnknownValue(component::UnknownValue),
    }

    #[doc(hidden)]
    pub mod component {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Component {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::SystemComponents => std::option::Option::Some(1),
                Self::Workloads => std::option::Option::Some(2),
                Self::Apiserver => std::option::Option::Some(3),
                Self::Scheduler => std::option::Option::Some(4),
                Self::ControllerManager => std::option::Option::Some(5),
                Self::KcpSshd => std::option::Option::Some(7),
                Self::KcpConnection => std::option::Option::Some(8),
                Self::KcpHpa => std::option::Option::Some(9),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("COMPONENT_UNSPECIFIED"),
                Self::SystemComponents => std::option::Option::Some("SYSTEM_COMPONENTS"),
                Self::Workloads => std::option::Option::Some("WORKLOADS"),
                Self::Apiserver => std::option::Option::Some("APISERVER"),
                Self::Scheduler => std::option::Option::Some("SCHEDULER"),
                Self::ControllerManager => std::option::Option::Some("CONTROLLER_MANAGER"),
                Self::KcpSshd => std::option::Option::Some("KCP_SSHD"),
                Self::KcpConnection => std::option::Option::Some("KCP_CONNECTION"),
                Self::KcpHpa => std::option::Option::Some("KCP_HPA"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Component {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Component {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Component {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::SystemComponents,
                2 => Self::Workloads,
                3 => Self::Apiserver,
                4 => Self::Scheduler,
                5 => Self::ControllerManager,
                7 => Self::KcpSshd,
                8 => Self::KcpConnection,
                9 => Self::KcpHpa,
                _ => Self::UnknownValue(component::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Component {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "COMPONENT_UNSPECIFIED" => Self::Unspecified,
                "SYSTEM_COMPONENTS" => Self::SystemComponents,
                "WORKLOADS" => Self::Workloads,
                "APISERVER" => Self::Apiserver,
                "SCHEDULER" => Self::Scheduler,
                "CONTROLLER_MANAGER" => Self::ControllerManager,
                "KCP_SSHD" => Self::KcpSshd,
                "KCP_CONNECTION" => Self::KcpConnection,
                "KCP_HPA" => Self::KcpHpa,
                _ => Self::UnknownValue(component::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Component {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::SystemComponents => serializer.serialize_i32(1),
                Self::Workloads => serializer.serialize_i32(2),
                Self::Apiserver => serializer.serialize_i32(3),
                Self::Scheduler => serializer.serialize_i32(4),
                Self::ControllerManager => serializer.serialize_i32(5),
                Self::KcpSshd => serializer.serialize_i32(7),
                Self::KcpConnection => serializer.serialize_i32(8),
                Self::KcpHpa => serializer.serialize_i32(9),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Component {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Component>::new(
                ".google.container.v1.LoggingComponentConfig.Component",
            ))
        }
    }
}

/// RayClusterLoggingConfig specifies configuration of Ray logging.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RayClusterLoggingConfig {
    /// Enable log collection for Ray clusters.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RayClusterLoggingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::RayClusterLoggingConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayClusterLoggingConfig;
    /// let x = RayClusterLoggingConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for RayClusterLoggingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RayClusterLoggingConfig"
    }
}

/// MonitoringConfig is cluster monitoring configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MonitoringConfig {
    /// Monitoring components configuration
    pub component_config: std::option::Option<crate::model::MonitoringComponentConfig>,

    /// Enable Google Cloud Managed Service for Prometheus
    /// in the cluster.
    pub managed_prometheus_config: std::option::Option<crate::model::ManagedPrometheusConfig>,

    /// Configuration of Advanced Datapath Observability features.
    pub advanced_datapath_observability_config:
        std::option::Option<crate::model::AdvancedDatapathObservabilityConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MonitoringConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [component_config][crate::model::MonitoringConfig::component_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::MonitoringComponentConfig;
    /// let x = MonitoringConfig::new().set_component_config(MonitoringComponentConfig::default()/* use setters */);
    /// ```
    pub fn set_component_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringComponentConfig>,
    {
        self.component_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [component_config][crate::model::MonitoringConfig::component_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::MonitoringComponentConfig;
    /// let x = MonitoringConfig::new().set_or_clear_component_config(Some(MonitoringComponentConfig::default()/* use setters */));
    /// let x = MonitoringConfig::new().set_or_clear_component_config(None::<MonitoringComponentConfig>);
    /// ```
    pub fn set_or_clear_component_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::MonitoringComponentConfig>,
    {
        self.component_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [managed_prometheus_config][crate::model::MonitoringConfig::managed_prometheus_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::ManagedPrometheusConfig;
    /// let x = MonitoringConfig::new().set_managed_prometheus_config(ManagedPrometheusConfig::default()/* use setters */);
    /// ```
    pub fn set_managed_prometheus_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::ManagedPrometheusConfig>,
    {
        self.managed_prometheus_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [managed_prometheus_config][crate::model::MonitoringConfig::managed_prometheus_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::ManagedPrometheusConfig;
    /// let x = MonitoringConfig::new().set_or_clear_managed_prometheus_config(Some(ManagedPrometheusConfig::default()/* use setters */));
    /// let x = MonitoringConfig::new().set_or_clear_managed_prometheus_config(None::<ManagedPrometheusConfig>);
    /// ```
    pub fn set_or_clear_managed_prometheus_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::ManagedPrometheusConfig>,
    {
        self.managed_prometheus_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [advanced_datapath_observability_config][crate::model::MonitoringConfig::advanced_datapath_observability_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// let x = MonitoringConfig::new().set_advanced_datapath_observability_config(AdvancedDatapathObservabilityConfig::default()/* use setters */);
    /// ```
    pub fn set_advanced_datapath_observability_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AdvancedDatapathObservabilityConfig>,
    {
        self.advanced_datapath_observability_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [advanced_datapath_observability_config][crate::model::MonitoringConfig::advanced_datapath_observability_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringConfig;
    /// use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// let x = MonitoringConfig::new().set_or_clear_advanced_datapath_observability_config(Some(AdvancedDatapathObservabilityConfig::default()/* use setters */));
    /// let x = MonitoringConfig::new().set_or_clear_advanced_datapath_observability_config(None::<AdvancedDatapathObservabilityConfig>);
    /// ```
    pub fn set_or_clear_advanced_datapath_observability_config<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<crate::model::AdvancedDatapathObservabilityConfig>,
    {
        self.advanced_datapath_observability_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for MonitoringConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MonitoringConfig"
    }
}

/// AdvancedDatapathObservabilityConfig specifies configuration of observability
/// features of advanced datapath.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AdvancedDatapathObservabilityConfig {
    /// Expose flow metrics on nodes
    pub enable_metrics: bool,

    /// Method used to make Relay available
    pub relay_mode: crate::model::advanced_datapath_observability_config::RelayMode,

    /// Enable Relay component
    pub enable_relay: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AdvancedDatapathObservabilityConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_metrics][crate::model::AdvancedDatapathObservabilityConfig::enable_metrics].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// let x = AdvancedDatapathObservabilityConfig::new().set_enable_metrics(true);
    /// ```
    pub fn set_enable_metrics<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enable_metrics = v.into();
        self
    }

    /// Sets the value of [relay_mode][crate::model::AdvancedDatapathObservabilityConfig::relay_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// use google_cloud_container_v1::model::advanced_datapath_observability_config::RelayMode;
    /// let x0 = AdvancedDatapathObservabilityConfig::new().set_relay_mode(RelayMode::Disabled);
    /// let x1 = AdvancedDatapathObservabilityConfig::new().set_relay_mode(RelayMode::InternalVpcLb);
    /// let x2 = AdvancedDatapathObservabilityConfig::new().set_relay_mode(RelayMode::ExternalLb);
    /// ```
    pub fn set_relay_mode<
        T: std::convert::Into<crate::model::advanced_datapath_observability_config::RelayMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.relay_mode = v.into();
        self
    }

    /// Sets the value of [enable_relay][crate::model::AdvancedDatapathObservabilityConfig::enable_relay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// let x = AdvancedDatapathObservabilityConfig::new().set_enable_relay(true);
    /// ```
    pub fn set_enable_relay<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_relay = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enable_relay][crate::model::AdvancedDatapathObservabilityConfig::enable_relay].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AdvancedDatapathObservabilityConfig;
    /// let x = AdvancedDatapathObservabilityConfig::new().set_or_clear_enable_relay(Some(false));
    /// let x = AdvancedDatapathObservabilityConfig::new().set_or_clear_enable_relay(None::<bool>);
    /// ```
    pub fn set_or_clear_enable_relay<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enable_relay = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for AdvancedDatapathObservabilityConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AdvancedDatapathObservabilityConfig"
    }
}

/// Defines additional types related to [AdvancedDatapathObservabilityConfig].
pub mod advanced_datapath_observability_config {
    #[allow(unused_imports)]
    use super::*;

    /// Supported Relay modes
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum RelayMode {
        /// Default value. This shouldn't be used.
        Unspecified,
        /// disabled
        Disabled,
        /// exposed via internal load balancer
        InternalVpcLb,
        /// exposed via external load balancer
        ExternalLb,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [RelayMode::value] or
        /// [RelayMode::name].
        UnknownValue(relay_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod relay_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl RelayMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(1),
                Self::InternalVpcLb => std::option::Option::Some(3),
                Self::ExternalLb => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("RELAY_MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::InternalVpcLb => std::option::Option::Some("INTERNAL_VPC_LB"),
                Self::ExternalLb => std::option::Option::Some("EXTERNAL_LB"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for RelayMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for RelayMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for RelayMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Disabled,
                3 => Self::InternalVpcLb,
                4 => Self::ExternalLb,
                _ => Self::UnknownValue(relay_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for RelayMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "RELAY_MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "INTERNAL_VPC_LB" => Self::InternalVpcLb,
                "EXTERNAL_LB" => Self::ExternalLb,
                _ => Self::UnknownValue(relay_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for RelayMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(1),
                Self::InternalVpcLb => serializer.serialize_i32(3),
                Self::ExternalLb => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for RelayMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<RelayMode>::new(
                ".google.container.v1.AdvancedDatapathObservabilityConfig.RelayMode",
            ))
        }
    }
}

/// RayClusterMonitoringConfig specifies monitoring configuration for Ray
/// clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct RayClusterMonitoringConfig {
    /// Enable metrics collection for Ray clusters.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl RayClusterMonitoringConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::RayClusterMonitoringConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::RayClusterMonitoringConfig;
    /// let x = RayClusterMonitoringConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for RayClusterMonitoringConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.RayClusterMonitoringConfig"
    }
}

/// NodePoolLoggingConfig specifies logging configuration for node pools.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePoolLoggingConfig {
    /// Logging variant configuration.
    pub variant_config: std::option::Option<crate::model::LoggingVariantConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePoolLoggingConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [variant_config][crate::model::NodePoolLoggingConfig::variant_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// use google_cloud_container_v1::model::LoggingVariantConfig;
    /// let x = NodePoolLoggingConfig::new().set_variant_config(LoggingVariantConfig::default()/* use setters */);
    /// ```
    pub fn set_variant_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::LoggingVariantConfig>,
    {
        self.variant_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [variant_config][crate::model::NodePoolLoggingConfig::variant_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolLoggingConfig;
    /// use google_cloud_container_v1::model::LoggingVariantConfig;
    /// let x = NodePoolLoggingConfig::new().set_or_clear_variant_config(Some(LoggingVariantConfig::default()/* use setters */));
    /// let x = NodePoolLoggingConfig::new().set_or_clear_variant_config(None::<LoggingVariantConfig>);
    /// ```
    pub fn set_or_clear_variant_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::LoggingVariantConfig>,
    {
        self.variant_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodePoolLoggingConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePoolLoggingConfig"
    }
}

/// LoggingVariantConfig specifies the behaviour of the logging component.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LoggingVariantConfig {
    /// Logging variant deployed on nodes.
    pub variant: crate::model::logging_variant_config::Variant,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LoggingVariantConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [variant][crate::model::LoggingVariantConfig::variant].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LoggingVariantConfig;
    /// use google_cloud_container_v1::model::logging_variant_config::Variant;
    /// let x0 = LoggingVariantConfig::new().set_variant(Variant::Default);
    /// let x1 = LoggingVariantConfig::new().set_variant(Variant::MaxThroughput);
    /// ```
    pub fn set_variant<T: std::convert::Into<crate::model::logging_variant_config::Variant>>(
        mut self,
        v: T,
    ) -> Self {
        self.variant = v.into();
        self
    }
}

impl wkt::message::Message for LoggingVariantConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LoggingVariantConfig"
    }
}

/// Defines additional types related to [LoggingVariantConfig].
pub mod logging_variant_config {
    #[allow(unused_imports)]
    use super::*;

    /// Logging component variants.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Variant {
        /// Default value. This shouldn't be used.
        Unspecified,
        /// default logging variant.
        Default,
        /// maximum logging throughput variant.
        MaxThroughput,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Variant::value] or
        /// [Variant::name].
        UnknownValue(variant::UnknownValue),
    }

    #[doc(hidden)]
    pub mod variant {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Variant {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Default => std::option::Option::Some(1),
                Self::MaxThroughput => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("VARIANT_UNSPECIFIED"),
                Self::Default => std::option::Option::Some("DEFAULT"),
                Self::MaxThroughput => std::option::Option::Some("MAX_THROUGHPUT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Variant {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Variant {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Variant {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Default,
                2 => Self::MaxThroughput,
                _ => Self::UnknownValue(variant::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Variant {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "VARIANT_UNSPECIFIED" => Self::Unspecified,
                "DEFAULT" => Self::Default,
                "MAX_THROUGHPUT" => Self::MaxThroughput,
                _ => Self::UnknownValue(variant::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Variant {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Default => serializer.serialize_i32(1),
                Self::MaxThroughput => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Variant {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Variant>::new(
                ".google.container.v1.LoggingVariantConfig.Variant",
            ))
        }
    }
}

/// MonitoringComponentConfig is cluster monitoring component configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MonitoringComponentConfig {
    /// Select components to collect metrics. An empty set would disable all
    /// monitoring.
    pub enable_components: std::vec::Vec<crate::model::monitoring_component_config::Component>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl MonitoringComponentConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enable_components][crate::model::MonitoringComponentConfig::enable_components].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::MonitoringComponentConfig;
    /// use google_cloud_container_v1::model::monitoring_component_config::Component;
    /// let x = MonitoringComponentConfig::new().set_enable_components([
    ///     Component::SystemComponents,
    ///     Component::Apiserver,
    ///     Component::Scheduler,
    /// ]);
    /// ```
    pub fn set_enable_components<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::monitoring_component_config::Component>,
    {
        use std::iter::Iterator;
        self.enable_components = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for MonitoringComponentConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.MonitoringComponentConfig"
    }
}

/// Defines additional types related to [MonitoringComponentConfig].
pub mod monitoring_component_config {
    #[allow(unused_imports)]
    use super::*;

    /// GKE components exposing metrics
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Component {
        /// Default value. This shouldn't be used.
        Unspecified,
        /// system components
        SystemComponents,
        /// kube-apiserver
        Apiserver,
        /// kube-scheduler
        Scheduler,
        /// kube-controller-manager
        ControllerManager,
        /// Storage
        Storage,
        /// Horizontal Pod Autoscaling
        Hpa,
        /// Pod
        Pod,
        /// DaemonSet
        Daemonset,
        /// Deployment
        Deployment,
        /// Statefulset
        Statefulset,
        /// CADVISOR
        Cadvisor,
        /// KUBELET
        Kubelet,
        /// NVIDIA Data Center GPU Manager (DCGM)
        Dcgm,
        /// JobSet
        Jobset,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Component::value] or
        /// [Component::name].
        UnknownValue(component::UnknownValue),
    }

    #[doc(hidden)]
    pub mod component {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Component {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::SystemComponents => std::option::Option::Some(1),
                Self::Apiserver => std::option::Option::Some(3),
                Self::Scheduler => std::option::Option::Some(4),
                Self::ControllerManager => std::option::Option::Some(5),
                Self::Storage => std::option::Option::Some(7),
                Self::Hpa => std::option::Option::Some(8),
                Self::Pod => std::option::Option::Some(9),
                Self::Daemonset => std::option::Option::Some(10),
                Self::Deployment => std::option::Option::Some(11),
                Self::Statefulset => std::option::Option::Some(12),
                Self::Cadvisor => std::option::Option::Some(13),
                Self::Kubelet => std::option::Option::Some(14),
                Self::Dcgm => std::option::Option::Some(15),
                Self::Jobset => std::option::Option::Some(16),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("COMPONENT_UNSPECIFIED"),
                Self::SystemComponents => std::option::Option::Some("SYSTEM_COMPONENTS"),
                Self::Apiserver => std::option::Option::Some("APISERVER"),
                Self::Scheduler => std::option::Option::Some("SCHEDULER"),
                Self::ControllerManager => std::option::Option::Some("CONTROLLER_MANAGER"),
                Self::Storage => std::option::Option::Some("STORAGE"),
                Self::Hpa => std::option::Option::Some("HPA"),
                Self::Pod => std::option::Option::Some("POD"),
                Self::Daemonset => std::option::Option::Some("DAEMONSET"),
                Self::Deployment => std::option::Option::Some("DEPLOYMENT"),
                Self::Statefulset => std::option::Option::Some("STATEFULSET"),
                Self::Cadvisor => std::option::Option::Some("CADVISOR"),
                Self::Kubelet => std::option::Option::Some("KUBELET"),
                Self::Dcgm => std::option::Option::Some("DCGM"),
                Self::Jobset => std::option::Option::Some("JOBSET"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Component {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Component {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Component {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::SystemComponents,
                3 => Self::Apiserver,
                4 => Self::Scheduler,
                5 => Self::ControllerManager,
                7 => Self::Storage,
                8 => Self::Hpa,
                9 => Self::Pod,
                10 => Self::Daemonset,
                11 => Self::Deployment,
                12 => Self::Statefulset,
                13 => Self::Cadvisor,
                14 => Self::Kubelet,
                15 => Self::Dcgm,
                16 => Self::Jobset,
                _ => Self::UnknownValue(component::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Component {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "COMPONENT_UNSPECIFIED" => Self::Unspecified,
                "SYSTEM_COMPONENTS" => Self::SystemComponents,
                "APISERVER" => Self::Apiserver,
                "SCHEDULER" => Self::Scheduler,
                "CONTROLLER_MANAGER" => Self::ControllerManager,
                "STORAGE" => Self::Storage,
                "HPA" => Self::Hpa,
                "POD" => Self::Pod,
                "DAEMONSET" => Self::Daemonset,
                "DEPLOYMENT" => Self::Deployment,
                "STATEFULSET" => Self::Statefulset,
                "CADVISOR" => Self::Cadvisor,
                "KUBELET" => Self::Kubelet,
                "DCGM" => Self::Dcgm,
                "JOBSET" => Self::Jobset,
                _ => Self::UnknownValue(component::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Component {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::SystemComponents => serializer.serialize_i32(1),
                Self::Apiserver => serializer.serialize_i32(3),
                Self::Scheduler => serializer.serialize_i32(4),
                Self::ControllerManager => serializer.serialize_i32(5),
                Self::Storage => serializer.serialize_i32(7),
                Self::Hpa => serializer.serialize_i32(8),
                Self::Pod => serializer.serialize_i32(9),
                Self::Daemonset => serializer.serialize_i32(10),
                Self::Deployment => serializer.serialize_i32(11),
                Self::Statefulset => serializer.serialize_i32(12),
                Self::Cadvisor => serializer.serialize_i32(13),
                Self::Kubelet => serializer.serialize_i32(14),
                Self::Dcgm => serializer.serialize_i32(15),
                Self::Jobset => serializer.serialize_i32(16),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Component {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Component>::new(
                ".google.container.v1.MonitoringComponentConfig.Component",
            ))
        }
    }
}

/// DataplaneV2Config is the configuration for DPv2.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DataplaneV2Config {
    /// Optional. Scalability mode for the cluster.
    pub scalability_mode: std::option::Option<crate::model::dataplane_v_2_config::ScalabilityMode>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DataplaneV2Config {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [scalability_mode][crate::model::DataplaneV2Config::scalability_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DataplaneV2Config;
    /// use google_cloud_container_v1::model::dataplane_v_2_config::ScalabilityMode;
    /// let x0 = DataplaneV2Config::new().set_scalability_mode(ScalabilityMode::Disabled);
    /// let x1 = DataplaneV2Config::new().set_scalability_mode(ScalabilityMode::ScaleOptimized);
    /// ```
    pub fn set_scalability_mode<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::dataplane_v_2_config::ScalabilityMode>,
    {
        self.scalability_mode = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [scalability_mode][crate::model::DataplaneV2Config::scalability_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::DataplaneV2Config;
    /// use google_cloud_container_v1::model::dataplane_v_2_config::ScalabilityMode;
    /// let x0 = DataplaneV2Config::new().set_or_clear_scalability_mode(Some(ScalabilityMode::Disabled));
    /// let x1 = DataplaneV2Config::new().set_or_clear_scalability_mode(Some(ScalabilityMode::ScaleOptimized));
    /// let x_none = DataplaneV2Config::new().set_or_clear_scalability_mode(None::<ScalabilityMode>);
    /// ```
    pub fn set_or_clear_scalability_mode<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::dataplane_v_2_config::ScalabilityMode>,
    {
        self.scalability_mode = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for DataplaneV2Config {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.DataplaneV2Config"
    }
}

/// Defines additional types related to [DataplaneV2Config].
pub mod dataplane_v_2_config {
    #[allow(unused_imports)]
    use super::*;

    /// Options on how to scale the cluster.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum ScalabilityMode {
        /// Default value.
        Unspecified,
        /// Disables the scale optimized mode for DPv2.
        Disabled,
        /// Enables the scale optimized mode for DPv2.
        ScaleOptimized,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ScalabilityMode::value] or
        /// [ScalabilityMode::name].
        UnknownValue(scalability_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod scalability_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ScalabilityMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Disabled => std::option::Option::Some(3),
                Self::ScaleOptimized => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("SCALABILITY_MODE_UNSPECIFIED"),
                Self::Disabled => std::option::Option::Some("DISABLED"),
                Self::ScaleOptimized => std::option::Option::Some("SCALE_OPTIMIZED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ScalabilityMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ScalabilityMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ScalabilityMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                3 => Self::Disabled,
                4 => Self::ScaleOptimized,
                _ => Self::UnknownValue(scalability_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ScalabilityMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SCALABILITY_MODE_UNSPECIFIED" => Self::Unspecified,
                "DISABLED" => Self::Disabled,
                "SCALE_OPTIMIZED" => Self::ScaleOptimized,
                _ => Self::UnknownValue(scalability_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ScalabilityMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Disabled => serializer.serialize_i32(3),
                Self::ScaleOptimized => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ScalabilityMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<ScalabilityMode>::new(
                ".google.container.v1.DataplaneV2Config.ScalabilityMode",
            ))
        }
    }
}

/// ManagedPrometheusConfig defines the configuration for
/// Google Cloud Managed Service for Prometheus.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ManagedPrometheusConfig {
    /// Enable Managed Collection.
    pub enabled: bool,

    /// GKE Workload Auto-Monitoring Configuration.
    pub auto_monitoring_config: std::option::Option<crate::model::AutoMonitoringConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ManagedPrometheusConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ManagedPrometheusConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedPrometheusConfig;
    /// let x = ManagedPrometheusConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }

    /// Sets the value of [auto_monitoring_config][crate::model::ManagedPrometheusConfig::auto_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedPrometheusConfig;
    /// use google_cloud_container_v1::model::AutoMonitoringConfig;
    /// let x = ManagedPrometheusConfig::new().set_auto_monitoring_config(AutoMonitoringConfig::default()/* use setters */);
    /// ```
    pub fn set_auto_monitoring_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AutoMonitoringConfig>,
    {
        self.auto_monitoring_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [auto_monitoring_config][crate::model::ManagedPrometheusConfig::auto_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedPrometheusConfig;
    /// use google_cloud_container_v1::model::AutoMonitoringConfig;
    /// let x = ManagedPrometheusConfig::new().set_or_clear_auto_monitoring_config(Some(AutoMonitoringConfig::default()/* use setters */));
    /// let x = ManagedPrometheusConfig::new().set_or_clear_auto_monitoring_config(None::<AutoMonitoringConfig>);
    /// ```
    pub fn set_or_clear_auto_monitoring_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::AutoMonitoringConfig>,
    {
        self.auto_monitoring_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ManagedPrometheusConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ManagedPrometheusConfig"
    }
}

/// AutoMonitoringConfig defines the configuration for GKE Workload
/// Auto-Monitoring.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AutoMonitoringConfig {
    /// Scope for GKE Workload Auto-Monitoring.
    pub scope: crate::model::auto_monitoring_config::Scope,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl AutoMonitoringConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [scope][crate::model::AutoMonitoringConfig::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::AutoMonitoringConfig;
    /// use google_cloud_container_v1::model::auto_monitoring_config::Scope;
    /// let x0 = AutoMonitoringConfig::new().set_scope(Scope::All);
    /// let x1 = AutoMonitoringConfig::new().set_scope(Scope::None);
    /// ```
    pub fn set_scope<T: std::convert::Into<crate::model::auto_monitoring_config::Scope>>(
        mut self,
        v: T,
    ) -> Self {
        self.scope = v.into();
        self
    }
}

impl wkt::message::Message for AutoMonitoringConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.AutoMonitoringConfig"
    }
}

/// Defines additional types related to [AutoMonitoringConfig].
pub mod auto_monitoring_config {
    #[allow(unused_imports)]
    use super::*;

    /// Scope for applications monitored by Auto-Monitoring
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Scope {
        /// Not set.
        Unspecified,
        /// Auto-Monitoring is enabled for all supported applications.
        All,
        /// Disable Auto-Monitoring.
        None,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Scope::value] or
        /// [Scope::name].
        UnknownValue(scope::UnknownValue),
    }

    #[doc(hidden)]
    pub mod scope {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Scope {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::All => std::option::Option::Some(1),
                Self::None => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("SCOPE_UNSPECIFIED"),
                Self::All => std::option::Option::Some("ALL"),
                Self::None => std::option::Option::Some("NONE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Scope {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Scope {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Scope {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::All,
                2 => Self::None,
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Scope {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SCOPE_UNSPECIFIED" => Self::Unspecified,
                "ALL" => Self::All,
                "NONE" => Self::None,
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Scope {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::All => serializer.serialize_i32(1),
                Self::None => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Scope {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Scope>::new(
                ".google.container.v1.AutoMonitoringConfig.Scope",
            ))
        }
    }
}

/// PodAutoscaling is used for configuration of parameters
/// for workload autoscaling.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PodAutoscaling {
    /// Selected Horizontal Pod Autoscaling profile.
    pub hpa_profile: std::option::Option<crate::model::pod_autoscaling::HPAProfile>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PodAutoscaling {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [hpa_profile][crate::model::PodAutoscaling::hpa_profile].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PodAutoscaling;
    /// use google_cloud_container_v1::model::pod_autoscaling::HPAProfile;
    /// let x0 = PodAutoscaling::new().set_hpa_profile(HPAProfile::None);
    /// let x1 = PodAutoscaling::new().set_hpa_profile(HPAProfile::Performance);
    /// ```
    pub fn set_hpa_profile<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::pod_autoscaling::HPAProfile>,
    {
        self.hpa_profile = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [hpa_profile][crate::model::PodAutoscaling::hpa_profile].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PodAutoscaling;
    /// use google_cloud_container_v1::model::pod_autoscaling::HPAProfile;
    /// let x0 = PodAutoscaling::new().set_or_clear_hpa_profile(Some(HPAProfile::None));
    /// let x1 = PodAutoscaling::new().set_or_clear_hpa_profile(Some(HPAProfile::Performance));
    /// let x_none = PodAutoscaling::new().set_or_clear_hpa_profile(None::<HPAProfile>);
    /// ```
    pub fn set_or_clear_hpa_profile<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::pod_autoscaling::HPAProfile>,
    {
        self.hpa_profile = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for PodAutoscaling {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PodAutoscaling"
    }
}

/// Defines additional types related to [PodAutoscaling].
pub mod pod_autoscaling {
    #[allow(unused_imports)]
    use super::*;

    /// Possible types of Horizontal Pod Autoscaling profile.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum HPAProfile {
        /// HPA_PROFILE_UNSPECIFIED is used when no custom HPA profile is set.
        Unspecified,
        /// Customers explicitly opt-out of HPA profiles.
        None,
        /// PERFORMANCE is used when customers opt-in to the performance HPA profile.
        /// In this profile we support a higher number of HPAs per cluster and faster
        /// metrics collection for workload autoscaling.
        Performance,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [HPAProfile::value] or
        /// [HPAProfile::name].
        UnknownValue(hpa_profile::UnknownValue),
    }

    #[doc(hidden)]
    pub mod hpa_profile {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl HPAProfile {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::None => std::option::Option::Some(1),
                Self::Performance => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("HPA_PROFILE_UNSPECIFIED"),
                Self::None => std::option::Option::Some("NONE"),
                Self::Performance => std::option::Option::Some("PERFORMANCE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for HPAProfile {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for HPAProfile {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for HPAProfile {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::None,
                2 => Self::Performance,
                _ => Self::UnknownValue(hpa_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for HPAProfile {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "HPA_PROFILE_UNSPECIFIED" => Self::Unspecified,
                "NONE" => Self::None,
                "PERFORMANCE" => Self::Performance,
                _ => Self::UnknownValue(hpa_profile::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for HPAProfile {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::None => serializer.serialize_i32(1),
                Self::Performance => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for HPAProfile {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<HPAProfile>::new(
                ".google.container.v1.PodAutoscaling.HPAProfile",
            ))
        }
    }
}

/// Fleet is the fleet configuration for the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Fleet {
    /// The Fleet host project(project ID or project number) where this cluster
    /// will be registered to. This field cannot be changed after the cluster has
    /// been registered.
    pub project: std::string::String,

    /// Output only. The full resource name of the registered fleet membership of
    /// the cluster, in the format
    /// `//gkehub.googleapis.com/projects/*/locations/*/memberships/*`.
    pub membership: std::string::String,

    /// Output only. Whether the cluster has been registered through the fleet
    /// API.
    pub pre_registered: bool,

    /// The type of the cluster's fleet membership.
    pub membership_type: crate::model::fleet::MembershipType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl Fleet {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project][crate::model::Fleet::project].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Fleet;
    /// let x = Fleet::new().set_project("example");
    /// ```
    pub fn set_project<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.project = v.into();
        self
    }

    /// Sets the value of [membership][crate::model::Fleet::membership].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Fleet;
    /// let x = Fleet::new().set_membership("example");
    /// ```
    pub fn set_membership<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.membership = v.into();
        self
    }

    /// Sets the value of [pre_registered][crate::model::Fleet::pre_registered].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Fleet;
    /// let x = Fleet::new().set_pre_registered(true);
    /// ```
    pub fn set_pre_registered<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.pre_registered = v.into();
        self
    }

    /// Sets the value of [membership_type][crate::model::Fleet::membership_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::Fleet;
    /// use google_cloud_container_v1::model::fleet::MembershipType;
    /// let x0 = Fleet::new().set_membership_type(MembershipType::Lightweight);
    /// ```
    pub fn set_membership_type<T: std::convert::Into<crate::model::fleet::MembershipType>>(
        mut self,
        v: T,
    ) -> Self {
        self.membership_type = v.into();
        self
    }
}

impl wkt::message::Message for Fleet {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.Fleet"
    }
}

/// Defines additional types related to [Fleet].
pub mod fleet {
    #[allow(unused_imports)]
    use super::*;

    /// MembershipType describes if the membership supports all features or only
    /// lightweight compatible ones.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum MembershipType {
        /// The MembershipType is not set.
        Unspecified,
        /// The membership supports only lightweight compatible features.
        Lightweight,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [MembershipType::value] or
        /// [MembershipType::name].
        UnknownValue(membership_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod membership_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl MembershipType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Lightweight => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MEMBERSHIP_TYPE_UNSPECIFIED"),
                Self::Lightweight => std::option::Option::Some("LIGHTWEIGHT"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for MembershipType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for MembershipType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for MembershipType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Lightweight,
                _ => Self::UnknownValue(membership_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for MembershipType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MEMBERSHIP_TYPE_UNSPECIFIED" => Self::Unspecified,
                "LIGHTWEIGHT" => Self::Lightweight,
                _ => Self::UnknownValue(membership_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for MembershipType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Lightweight => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for MembershipType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<MembershipType>::new(
                ".google.container.v1.Fleet.MembershipType",
            ))
        }
    }
}

/// Configuration for all of the cluster's control plane endpoints.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ControlPlaneEndpointsConfig {
    /// DNS endpoint configuration.
    pub dns_endpoint_config:
        std::option::Option<crate::model::control_plane_endpoints_config::DNSEndpointConfig>,

    /// IP endpoints configuration.
    pub ip_endpoints_config:
        std::option::Option<crate::model::control_plane_endpoints_config::IPEndpointsConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ControlPlaneEndpointsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [dns_endpoint_config][crate::model::ControlPlaneEndpointsConfig::dns_endpoint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
    /// let x = ControlPlaneEndpointsConfig::new().set_dns_endpoint_config(DNSEndpointConfig::default()/* use setters */);
    /// ```
    pub fn set_dns_endpoint_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::control_plane_endpoints_config::DNSEndpointConfig>,
    {
        self.dns_endpoint_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [dns_endpoint_config][crate::model::ControlPlaneEndpointsConfig::dns_endpoint_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
    /// let x = ControlPlaneEndpointsConfig::new().set_or_clear_dns_endpoint_config(Some(DNSEndpointConfig::default()/* use setters */));
    /// let x = ControlPlaneEndpointsConfig::new().set_or_clear_dns_endpoint_config(None::<DNSEndpointConfig>);
    /// ```
    pub fn set_or_clear_dns_endpoint_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::control_plane_endpoints_config::DNSEndpointConfig>,
    {
        self.dns_endpoint_config = v.map(|x| x.into());
        self
    }

    /// Sets the value of [ip_endpoints_config][crate::model::ControlPlaneEndpointsConfig::ip_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
    /// let x = ControlPlaneEndpointsConfig::new().set_ip_endpoints_config(IPEndpointsConfig::default()/* use setters */);
    /// ```
    pub fn set_ip_endpoints_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::control_plane_endpoints_config::IPEndpointsConfig>,
    {
        self.ip_endpoints_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [ip_endpoints_config][crate::model::ControlPlaneEndpointsConfig::ip_endpoints_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ControlPlaneEndpointsConfig;
    /// use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
    /// let x = ControlPlaneEndpointsConfig::new().set_or_clear_ip_endpoints_config(Some(IPEndpointsConfig::default()/* use setters */));
    /// let x = ControlPlaneEndpointsConfig::new().set_or_clear_ip_endpoints_config(None::<IPEndpointsConfig>);
    /// ```
    pub fn set_or_clear_ip_endpoints_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::control_plane_endpoints_config::IPEndpointsConfig>,
    {
        self.ip_endpoints_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ControlPlaneEndpointsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ControlPlaneEndpointsConfig"
    }
}

/// Defines additional types related to [ControlPlaneEndpointsConfig].
pub mod control_plane_endpoints_config {
    #[allow(unused_imports)]
    use super::*;

    /// Describes the configuration of a DNS endpoint.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct DNSEndpointConfig {
        /// Output only. The cluster's DNS endpoint configuration.
        /// A DNS format address. This is accessible from the public internet.
        /// Ex: uid.us-central1.gke.goog.
        /// Always present, but the behavior may change according to the value of
        /// [DNSEndpointConfig.allow_external_traffic][google.container.v1.ControlPlaneEndpointsConfig.DNSEndpointConfig.allow_external_traffic].
        ///
        /// [google.container.v1.ControlPlaneEndpointsConfig.DNSEndpointConfig.allow_external_traffic]: crate::model::control_plane_endpoints_config::DNSEndpointConfig::allow_external_traffic
        pub endpoint: std::string::String,

        /// Controls whether user traffic is allowed over this endpoint. Note that
        /// Google-managed services may still use the endpoint even if this is false.
        pub allow_external_traffic: std::option::Option<bool>,

        /// Controls whether the k8s token auth is allowed via DNS.
        pub enable_k8s_tokens_via_dns: std::option::Option<bool>,

        /// Controls whether the k8s certs auth is allowed via DNS.
        pub enable_k8s_certs_via_dns: std::option::Option<bool>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl DNSEndpointConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [endpoint][crate::model::control_plane_endpoints_config::DNSEndpointConfig::endpoint].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_endpoint("example");
        /// ```
        pub fn set_endpoint<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
            self.endpoint = v.into();
            self
        }

        /// Sets the value of [allow_external_traffic][crate::model::control_plane_endpoints_config::DNSEndpointConfig::allow_external_traffic].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_allow_external_traffic(true);
        /// ```
        pub fn set_allow_external_traffic<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.allow_external_traffic = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [allow_external_traffic][crate::model::control_plane_endpoints_config::DNSEndpointConfig::allow_external_traffic].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_or_clear_allow_external_traffic(Some(false));
        /// let x = DNSEndpointConfig::new().set_or_clear_allow_external_traffic(None::<bool>);
        /// ```
        pub fn set_or_clear_allow_external_traffic<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.allow_external_traffic = v.map(|x| x.into());
            self
        }

        /// Sets the value of [enable_k8s_tokens_via_dns][crate::model::control_plane_endpoints_config::DNSEndpointConfig::enable_k8s_tokens_via_dns].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_enable_k8s_tokens_via_dns(true);
        /// ```
        pub fn set_enable_k8s_tokens_via_dns<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_k8s_tokens_via_dns = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enable_k8s_tokens_via_dns][crate::model::control_plane_endpoints_config::DNSEndpointConfig::enable_k8s_tokens_via_dns].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_or_clear_enable_k8s_tokens_via_dns(Some(false));
        /// let x = DNSEndpointConfig::new().set_or_clear_enable_k8s_tokens_via_dns(None::<bool>);
        /// ```
        pub fn set_or_clear_enable_k8s_tokens_via_dns<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_k8s_tokens_via_dns = v.map(|x| x.into());
            self
        }

        /// Sets the value of [enable_k8s_certs_via_dns][crate::model::control_plane_endpoints_config::DNSEndpointConfig::enable_k8s_certs_via_dns].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_enable_k8s_certs_via_dns(true);
        /// ```
        pub fn set_enable_k8s_certs_via_dns<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_k8s_certs_via_dns = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enable_k8s_certs_via_dns][crate::model::control_plane_endpoints_config::DNSEndpointConfig::enable_k8s_certs_via_dns].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::DNSEndpointConfig;
        /// let x = DNSEndpointConfig::new().set_or_clear_enable_k8s_certs_via_dns(Some(false));
        /// let x = DNSEndpointConfig::new().set_or_clear_enable_k8s_certs_via_dns(None::<bool>);
        /// ```
        pub fn set_or_clear_enable_k8s_certs_via_dns<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_k8s_certs_via_dns = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for DNSEndpointConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ControlPlaneEndpointsConfig.DNSEndpointConfig"
        }
    }

    /// IP endpoints configuration.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct IPEndpointsConfig {
        /// Controls whether to allow direct IP access.
        pub enabled: std::option::Option<bool>,

        /// Controls whether the control plane allows access through a public IP.
        /// It is invalid to specify both
        /// [PrivateClusterConfig.enablePrivateEndpoint][] and this field at the same
        /// time.
        pub enable_public_endpoint: std::option::Option<bool>,

        /// Controls whether the control plane's private endpoint is accessible from
        /// sources in other regions.
        /// It is invalid to specify both
        /// [PrivateClusterMasterGlobalAccessConfig.enabled][google.container.v1.PrivateClusterMasterGlobalAccessConfig.enabled]
        /// and this field at the same time.
        ///
        /// [google.container.v1.PrivateClusterMasterGlobalAccessConfig.enabled]: crate::model::PrivateClusterMasterGlobalAccessConfig::enabled
        pub global_access: std::option::Option<bool>,

        /// Configuration of authorized networks. If enabled, restricts access to the
        /// control plane based on source IP.
        /// It is invalid to specify both
        /// [Cluster.masterAuthorizedNetworksConfig][] and this field at the same
        /// time.
        pub authorized_networks_config:
            std::option::Option<crate::model::MasterAuthorizedNetworksConfig>,

        /// Output only. The external IP address of this cluster's control plane.
        /// Only populated if enabled.
        pub public_endpoint: std::string::String,

        /// Output only. The internal IP address of this cluster's control plane.
        /// Only populated if enabled.
        pub private_endpoint: std::string::String,

        /// Subnet to provision the master's private endpoint during cluster
        /// creation. Specified in projects/*/regions/*/subnetworks/* format. It is
        /// invalid to specify both
        /// [PrivateClusterConfig.privateEndpointSubnetwork][] and this field at the
        /// same time.
        pub private_endpoint_subnetwork: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl IPEndpointsConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::control_plane_endpoints_config::IPEndpointsConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enabled][crate::model::control_plane_endpoints_config::IPEndpointsConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_or_clear_enabled(Some(false));
        /// let x = IPEndpointsConfig::new().set_or_clear_enabled(None::<bool>);
        /// ```
        pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = v.map(|x| x.into());
            self
        }

        /// Sets the value of [enable_public_endpoint][crate::model::control_plane_endpoints_config::IPEndpointsConfig::enable_public_endpoint].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_enable_public_endpoint(true);
        /// ```
        pub fn set_enable_public_endpoint<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_public_endpoint = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enable_public_endpoint][crate::model::control_plane_endpoints_config::IPEndpointsConfig::enable_public_endpoint].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_or_clear_enable_public_endpoint(Some(false));
        /// let x = IPEndpointsConfig::new().set_or_clear_enable_public_endpoint(None::<bool>);
        /// ```
        pub fn set_or_clear_enable_public_endpoint<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enable_public_endpoint = v.map(|x| x.into());
            self
        }

        /// Sets the value of [global_access][crate::model::control_plane_endpoints_config::IPEndpointsConfig::global_access].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_global_access(true);
        /// ```
        pub fn set_global_access<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.global_access = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [global_access][crate::model::control_plane_endpoints_config::IPEndpointsConfig::global_access].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_or_clear_global_access(Some(false));
        /// let x = IPEndpointsConfig::new().set_or_clear_global_access(None::<bool>);
        /// ```
        pub fn set_or_clear_global_access<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.global_access = v.map(|x| x.into());
            self
        }

        /// Sets the value of [authorized_networks_config][crate::model::control_plane_endpoints_config::IPEndpointsConfig::authorized_networks_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
        /// let x = IPEndpointsConfig::new().set_authorized_networks_config(MasterAuthorizedNetworksConfig::default()/* use setters */);
        /// ```
        pub fn set_authorized_networks_config<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
        {
            self.authorized_networks_config = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [authorized_networks_config][crate::model::control_plane_endpoints_config::IPEndpointsConfig::authorized_networks_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// use google_cloud_container_v1::model::MasterAuthorizedNetworksConfig;
        /// let x = IPEndpointsConfig::new().set_or_clear_authorized_networks_config(Some(MasterAuthorizedNetworksConfig::default()/* use setters */));
        /// let x = IPEndpointsConfig::new().set_or_clear_authorized_networks_config(None::<MasterAuthorizedNetworksConfig>);
        /// ```
        pub fn set_or_clear_authorized_networks_config<T>(
            mut self,
            v: std::option::Option<T>,
        ) -> Self
        where
            T: std::convert::Into<crate::model::MasterAuthorizedNetworksConfig>,
        {
            self.authorized_networks_config = v.map(|x| x.into());
            self
        }

        /// Sets the value of [public_endpoint][crate::model::control_plane_endpoints_config::IPEndpointsConfig::public_endpoint].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_public_endpoint("example");
        /// ```
        pub fn set_public_endpoint<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.public_endpoint = v.into();
            self
        }

        /// Sets the value of [private_endpoint][crate::model::control_plane_endpoints_config::IPEndpointsConfig::private_endpoint].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_private_endpoint("example");
        /// ```
        pub fn set_private_endpoint<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.private_endpoint = v.into();
            self
        }

        /// Sets the value of [private_endpoint_subnetwork][crate::model::control_plane_endpoints_config::IPEndpointsConfig::private_endpoint_subnetwork].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::control_plane_endpoints_config::IPEndpointsConfig;
        /// let x = IPEndpointsConfig::new().set_private_endpoint_subnetwork("example");
        /// ```
        pub fn set_private_endpoint_subnetwork<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.private_endpoint_subnetwork = v.into();
            self
        }
    }

    impl wkt::message::Message for IPEndpointsConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.ControlPlaneEndpointsConfig.IPEndpointsConfig"
        }
    }
}

/// LocalNvmeSsdBlockConfig contains configuration for using raw-block local
/// NVMe SSDs
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LocalNvmeSsdBlockConfig {
    /// Number of local NVMe SSDs to use.  The limit for this value is dependent
    /// upon the maximum number of disk available on a machine per zone. See:
    /// <https://cloud.google.com/compute/docs/disks/local-ssd>
    /// for more information.
    ///
    /// A zero (or unset) value has different meanings depending on machine type
    /// being used:
    ///
    /// 1. For pre-Gen3 machines, which support flexible numbers of local ssds,
    ///    zero (or unset) means to disable using local SSDs as ephemeral storage.
    /// 1. For Gen3 machines which dictate a specific number of local ssds, zero
    ///    (or unset) means to use the default number of local ssds that goes with
    ///    that machine type. For example, for a c3-standard-8-lssd machine, 2 local
    ///    ssds would be provisioned. For c3-standard-8 (which doesn't support local
    ///    ssds), 0 will be provisioned. See
    ///    <https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds>
    ///    for more info.
    pub local_ssd_count: i32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl LocalNvmeSsdBlockConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [local_ssd_count][crate::model::LocalNvmeSsdBlockConfig::local_ssd_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::LocalNvmeSsdBlockConfig;
    /// let x = LocalNvmeSsdBlockConfig::new().set_local_ssd_count(42);
    /// ```
    pub fn set_local_ssd_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.local_ssd_count = v.into();
        self
    }
}

impl wkt::message::Message for LocalNvmeSsdBlockConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.LocalNvmeSsdBlockConfig"
    }
}

/// EphemeralStorageLocalSsdConfig contains configuration for the node ephemeral
/// storage using Local SSDs.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct EphemeralStorageLocalSsdConfig {
    /// Number of local SSDs to use to back ephemeral storage. Uses NVMe
    /// interfaces.
    ///
    /// A zero (or unset) value has different meanings depending on machine type
    /// being used:
    ///
    /// 1. For pre-Gen3 machines, which support flexible numbers of local ssds,
    ///    zero (or unset) means to disable using local SSDs as ephemeral storage. The
    ///    limit for this value is dependent upon the maximum number of disk
    ///    available on a machine per zone. See:
    ///    <https://cloud.google.com/compute/docs/disks/local-ssd>
    ///    for more information.
    /// 1. For Gen3 machines which dictate a specific number of local ssds, zero
    ///    (or unset) means to use the default number of local ssds that goes with
    ///    that machine type. For example, for a c3-standard-8-lssd machine, 2 local
    ///    ssds would be provisioned. For c3-standard-8 (which doesn't support local
    ///    ssds), 0 will be provisioned. See
    ///    <https://cloud.google.com/compute/docs/disks/local-ssd#choose_number_local_ssds>
    ///    for more info.
    pub local_ssd_count: i32,

    /// Number of local SSDs to use for GKE Data Cache.
    pub data_cache_count: i32,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EphemeralStorageLocalSsdConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [local_ssd_count][crate::model::EphemeralStorageLocalSsdConfig::local_ssd_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EphemeralStorageLocalSsdConfig;
    /// let x = EphemeralStorageLocalSsdConfig::new().set_local_ssd_count(42);
    /// ```
    pub fn set_local_ssd_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.local_ssd_count = v.into();
        self
    }

    /// Sets the value of [data_cache_count][crate::model::EphemeralStorageLocalSsdConfig::data_cache_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EphemeralStorageLocalSsdConfig;
    /// let x = EphemeralStorageLocalSsdConfig::new().set_data_cache_count(42);
    /// ```
    pub fn set_data_cache_count<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.data_cache_count = v.into();
        self
    }
}

impl wkt::message::Message for EphemeralStorageLocalSsdConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.EphemeralStorageLocalSsdConfig"
    }
}

/// A map of resource manager tag keys and values to be attached to the nodes
/// for managing Compute Engine firewalls using Network Firewall Policies.
/// Tags must be according to specifications in
/// <https://cloud.google.com/vpc/docs/tags-firewalls-overview#specifications>.
/// A maximum of 5 tag key-value pairs can be specified.
/// Existing tags will be replaced with new values.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ResourceManagerTags {
    /// TagKeyValue must be in one of the following formats ([KEY]=[VALUE])
    ///
    /// 1. `tagKeys/{tag_key_id}=tagValues/{tag_value_id}`
    /// 1. `{org_id}/{tag_key_name}={tag_value_name}`
    /// 1. `{project_id}/{tag_key_name}={tag_value_name}`
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ResourceManagerTags {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [tags][crate::model::ResourceManagerTags::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ResourceManagerTags;
    /// let x = ResourceManagerTags::new().set_tags([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_tags<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.tags = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }
}

impl wkt::message::Message for ResourceManagerTags {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ResourceManagerTags"
    }
}

/// EnterpriseConfig is the cluster enterprise configuration.
///
/// Deprecated: GKE Enterprise features are now available without an Enterprise
/// tier.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct EnterpriseConfig {
    /// Output only. cluster_tier indicates the effective tier of the cluster.
    pub cluster_tier: crate::model::enterprise_config::ClusterTier,

    /// desired_tier specifies the desired tier of the cluster.
    pub desired_tier: crate::model::enterprise_config::ClusterTier,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl EnterpriseConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [cluster_tier][crate::model::EnterpriseConfig::cluster_tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EnterpriseConfig;
    /// use google_cloud_container_v1::model::enterprise_config::ClusterTier;
    /// let x0 = EnterpriseConfig::new().set_cluster_tier(ClusterTier::Standard);
    /// let x1 = EnterpriseConfig::new().set_cluster_tier(ClusterTier::Enterprise);
    /// ```
    pub fn set_cluster_tier<T: std::convert::Into<crate::model::enterprise_config::ClusterTier>>(
        mut self,
        v: T,
    ) -> Self {
        self.cluster_tier = v.into();
        self
    }

    /// Sets the value of [desired_tier][crate::model::EnterpriseConfig::desired_tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::EnterpriseConfig;
    /// use google_cloud_container_v1::model::enterprise_config::ClusterTier;
    /// let x0 = EnterpriseConfig::new().set_desired_tier(ClusterTier::Standard);
    /// let x1 = EnterpriseConfig::new().set_desired_tier(ClusterTier::Enterprise);
    /// ```
    pub fn set_desired_tier<T: std::convert::Into<crate::model::enterprise_config::ClusterTier>>(
        mut self,
        v: T,
    ) -> Self {
        self.desired_tier = v.into();
        self
    }
}

impl wkt::message::Message for EnterpriseConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.EnterpriseConfig"
    }
}

/// Defines additional types related to [EnterpriseConfig].
pub mod enterprise_config {
    #[allow(unused_imports)]
    use super::*;

    /// Premium tiers for GKE Cluster.
    ///
    /// Deprecated: GKE Enterprise features are now available without an Enterprise
    /// tier.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    #[deprecated]
    pub enum ClusterTier {
        /// CLUSTER_TIER_UNSPECIFIED is when cluster_tier is not set.
        Unspecified,
        /// STANDARD indicates a standard GKE cluster.
        Standard,
        /// ENTERPRISE indicates a GKE Enterprise cluster.
        Enterprise,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [ClusterTier::value] or
        /// [ClusterTier::name].
        UnknownValue(cluster_tier::UnknownValue),
    }

    #[doc(hidden)]
    pub mod cluster_tier {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl ClusterTier {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Standard => std::option::Option::Some(1),
                Self::Enterprise => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("CLUSTER_TIER_UNSPECIFIED"),
                Self::Standard => std::option::Option::Some("STANDARD"),
                Self::Enterprise => std::option::Option::Some("ENTERPRISE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for ClusterTier {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for ClusterTier {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for ClusterTier {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Standard,
                2 => Self::Enterprise,
                _ => Self::UnknownValue(cluster_tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for ClusterTier {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "CLUSTER_TIER_UNSPECIFIED" => Self::Unspecified,
                "STANDARD" => Self::Standard,
                "ENTERPRISE" => Self::Enterprise,
                _ => Self::UnknownValue(cluster_tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for ClusterTier {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Standard => serializer.serialize_i32(1),
                Self::Enterprise => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for ClusterTier {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<ClusterTier>::new(
                ".google.container.v1.EnterpriseConfig.ClusterTier",
            ))
        }
    }
}

/// SecretManagerConfig is config for secret manager enablement.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecretManagerConfig {
    /// Enable/Disable Secret Manager Config.
    pub enabled: std::option::Option<bool>,

    /// Rotation config for secret manager.
    pub rotation_config: std::option::Option<crate::model::secret_manager_config::RotationConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecretManagerConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::SecretManagerConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = SecretManagerConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enabled][crate::model::SecretManagerConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretManagerConfig;
    /// let x = SecretManagerConfig::new().set_or_clear_enabled(Some(false));
    /// let x = SecretManagerConfig::new().set_or_clear_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rotation_config][crate::model::SecretManagerConfig::rotation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretManagerConfig;
    /// use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
    /// let x = SecretManagerConfig::new().set_rotation_config(RotationConfig::default()/* use setters */);
    /// ```
    pub fn set_rotation_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::secret_manager_config::RotationConfig>,
    {
        self.rotation_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rotation_config][crate::model::SecretManagerConfig::rotation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretManagerConfig;
    /// use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
    /// let x = SecretManagerConfig::new().set_or_clear_rotation_config(Some(RotationConfig::default()/* use setters */));
    /// let x = SecretManagerConfig::new().set_or_clear_rotation_config(None::<RotationConfig>);
    /// ```
    pub fn set_or_clear_rotation_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::secret_manager_config::RotationConfig>,
    {
        self.rotation_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SecretManagerConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecretManagerConfig"
    }
}

/// Defines additional types related to [SecretManagerConfig].
pub mod secret_manager_config {
    #[allow(unused_imports)]
    use super::*;

    /// RotationConfig is config for secret manager auto rotation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct RotationConfig {
        /// Whether the rotation is enabled.
        pub enabled: std::option::Option<bool>,

        /// The interval between two consecutive rotations. Default rotation interval
        /// is 2 minutes.
        pub rotation_interval: std::option::Option<wkt::Duration>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl RotationConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::secret_manager_config::RotationConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
        /// let x = RotationConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enabled][crate::model::secret_manager_config::RotationConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
        /// let x = RotationConfig::new().set_or_clear_enabled(Some(false));
        /// let x = RotationConfig::new().set_or_clear_enabled(None::<bool>);
        /// ```
        pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = v.map(|x| x.into());
            self
        }

        /// Sets the value of [rotation_interval][crate::model::secret_manager_config::RotationConfig::rotation_interval].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
        /// use wkt::Duration;
        /// let x = RotationConfig::new().set_rotation_interval(Duration::default()/* use setters */);
        /// ```
        pub fn set_rotation_interval<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.rotation_interval = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [rotation_interval][crate::model::secret_manager_config::RotationConfig::rotation_interval].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_manager_config::RotationConfig;
        /// use wkt::Duration;
        /// let x = RotationConfig::new().set_or_clear_rotation_interval(Some(Duration::default()/* use setters */));
        /// let x = RotationConfig::new().set_or_clear_rotation_interval(None::<Duration>);
        /// ```
        pub fn set_or_clear_rotation_interval<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.rotation_interval = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for RotationConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.SecretManagerConfig.RotationConfig"
        }
    }
}

/// BootDisk specifies the boot disk configuration for node pools.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BootDisk {
    /// Disk type of the boot disk.
    /// (i.e. Hyperdisk-Balanced, PD-Balanced, etc.)
    pub disk_type: std::string::String,

    /// Disk size in GB. Replaces NodeConfig.disk_size_gb
    pub size_gb: i64,

    /// For Hyperdisk-Balanced only, the provisioned IOPS config value.
    pub provisioned_iops: i64,

    /// For Hyperdisk-Balanced only, the provisioned throughput config value.
    pub provisioned_throughput: i64,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BootDisk {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [disk_type][crate::model::BootDisk::disk_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BootDisk;
    /// let x = BootDisk::new().set_disk_type("example");
    /// ```
    pub fn set_disk_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.disk_type = v.into();
        self
    }

    /// Sets the value of [size_gb][crate::model::BootDisk::size_gb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BootDisk;
    /// let x = BootDisk::new().set_size_gb(42);
    /// ```
    pub fn set_size_gb<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.size_gb = v.into();
        self
    }

    /// Sets the value of [provisioned_iops][crate::model::BootDisk::provisioned_iops].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BootDisk;
    /// let x = BootDisk::new().set_provisioned_iops(42);
    /// ```
    pub fn set_provisioned_iops<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.provisioned_iops = v.into();
        self
    }

    /// Sets the value of [provisioned_throughput][crate::model::BootDisk::provisioned_throughput].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::BootDisk;
    /// let x = BootDisk::new().set_provisioned_throughput(42);
    /// ```
    pub fn set_provisioned_throughput<T: std::convert::Into<i64>>(mut self, v: T) -> Self {
        self.provisioned_throughput = v.into();
        self
    }
}

impl wkt::message::Message for BootDisk {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.BootDisk"
    }
}

/// SecondaryBootDisk represents a persistent disk attached to a node
/// with special configurations based on its mode.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecondaryBootDisk {
    /// Disk mode (container image cache, etc.)
    pub mode: crate::model::secondary_boot_disk::Mode,

    /// Fully-qualified resource ID for an existing disk image.
    pub disk_image: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecondaryBootDisk {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [mode][crate::model::SecondaryBootDisk::mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecondaryBootDisk;
    /// use google_cloud_container_v1::model::secondary_boot_disk::Mode;
    /// let x0 = SecondaryBootDisk::new().set_mode(Mode::ContainerImageCache);
    /// ```
    pub fn set_mode<T: std::convert::Into<crate::model::secondary_boot_disk::Mode>>(
        mut self,
        v: T,
    ) -> Self {
        self.mode = v.into();
        self
    }

    /// Sets the value of [disk_image][crate::model::SecondaryBootDisk::disk_image].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecondaryBootDisk;
    /// let x = SecondaryBootDisk::new().set_disk_image("example");
    /// ```
    pub fn set_disk_image<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.disk_image = v.into();
        self
    }
}

impl wkt::message::Message for SecondaryBootDisk {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecondaryBootDisk"
    }
}

/// Defines additional types related to [SecondaryBootDisk].
pub mod secondary_boot_disk {
    #[allow(unused_imports)]
    use super::*;

    /// Mode specifies how the secondary boot disk will be used.
    /// This triggers mode-specified logic in the control plane.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Mode {
        /// MODE_UNSPECIFIED is when mode is not set.
        Unspecified,
        /// CONTAINER_IMAGE_CACHE is for using the secondary boot disk as
        /// a container image cache.
        ContainerImageCache,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Mode::value] or
        /// [Mode::name].
        UnknownValue(mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Mode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::ContainerImageCache => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("MODE_UNSPECIFIED"),
                Self::ContainerImageCache => std::option::Option::Some("CONTAINER_IMAGE_CACHE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Mode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Mode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Mode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::ContainerImageCache,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Mode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "MODE_UNSPECIFIED" => Self::Unspecified,
                "CONTAINER_IMAGE_CACHE" => Self::ContainerImageCache,
                _ => Self::UnknownValue(mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Mode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::ContainerImageCache => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Mode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Mode>::new(
                ".google.container.v1.SecondaryBootDisk.Mode",
            ))
        }
    }
}

/// SecondaryBootDiskUpdateStrategy is a placeholder which will be extended
/// in the future to define different options for updating secondary boot disks.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecondaryBootDiskUpdateStrategy {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecondaryBootDiskUpdateStrategy {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }
}

impl wkt::message::Message for SecondaryBootDiskUpdateStrategy {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecondaryBootDiskUpdateStrategy"
    }
}

/// FetchClusterUpgradeInfoRequest fetches the upgrade information of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FetchClusterUpgradeInfoRequest {
    /// Required. The name (project, location, cluster) of the cluster to get.
    /// Specified in the format `projects/*/locations/*/clusters/*` or
    /// `projects/*/zones/*/clusters/*`.
    pub name: std::string::String,

    /// API request version that initiates this operation.
    pub version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FetchClusterUpgradeInfoRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::FetchClusterUpgradeInfoRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::FetchClusterUpgradeInfoRequest;
    /// let x = FetchClusterUpgradeInfoRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [version][crate::model::FetchClusterUpgradeInfoRequest::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::FetchClusterUpgradeInfoRequest;
    /// let x = FetchClusterUpgradeInfoRequest::new().set_version("example");
    /// ```
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }
}

impl wkt::message::Message for FetchClusterUpgradeInfoRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.FetchClusterUpgradeInfoRequest"
    }
}

/// ClusterUpgradeInfo contains the upgrade information of a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ClusterUpgradeInfo {
    /// minor_target_version indicates the target version for minor upgrade.
    pub minor_target_version: std::option::Option<std::string::String>,

    /// patch_target_version indicates the target version for patch upgrade.
    pub patch_target_version: std::option::Option<std::string::String>,

    /// The auto upgrade status.
    pub auto_upgrade_status: std::vec::Vec<crate::model::cluster_upgrade_info::AutoUpgradeStatus>,

    /// The auto upgrade paused reason.
    pub paused_reason: std::vec::Vec<crate::model::cluster_upgrade_info::AutoUpgradePausedReason>,

    /// The list of past auto upgrades.
    pub upgrade_details: std::vec::Vec<crate::model::UpgradeDetails>,

    /// The cluster's current minor version's end of standard support timestamp.
    pub end_of_standard_support_timestamp: std::option::Option<std::string::String>,

    /// The cluster's current minor version's end of extended support timestamp.
    pub end_of_extended_support_timestamp: std::option::Option<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ClusterUpgradeInfo {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [minor_target_version][crate::model::ClusterUpgradeInfo::minor_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_minor_target_version("example");
    /// ```
    pub fn set_minor_target_version<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.minor_target_version = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [minor_target_version][crate::model::ClusterUpgradeInfo::minor_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_or_clear_minor_target_version(Some("example"));
    /// let x = ClusterUpgradeInfo::new().set_or_clear_minor_target_version(None::<String>);
    /// ```
    pub fn set_or_clear_minor_target_version<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.minor_target_version = v.map(|x| x.into());
        self
    }

    /// Sets the value of [patch_target_version][crate::model::ClusterUpgradeInfo::patch_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_patch_target_version("example");
    /// ```
    pub fn set_patch_target_version<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.patch_target_version = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [patch_target_version][crate::model::ClusterUpgradeInfo::patch_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_or_clear_patch_target_version(Some("example"));
    /// let x = ClusterUpgradeInfo::new().set_or_clear_patch_target_version(None::<String>);
    /// ```
    pub fn set_or_clear_patch_target_version<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.patch_target_version = v.map(|x| x.into());
        self
    }

    /// Sets the value of [auto_upgrade_status][crate::model::ClusterUpgradeInfo::auto_upgrade_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// use google_cloud_container_v1::model::cluster_upgrade_info::AutoUpgradeStatus;
    /// let x = ClusterUpgradeInfo::new().set_auto_upgrade_status([
    ///     AutoUpgradeStatus::Active,
    ///     AutoUpgradeStatus::MinorUpgradePaused,
    ///     AutoUpgradeStatus::UpgradePaused,
    /// ]);
    /// ```
    pub fn set_auto_upgrade_status<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::cluster_upgrade_info::AutoUpgradeStatus>,
    {
        use std::iter::Iterator;
        self.auto_upgrade_status = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [paused_reason][crate::model::ClusterUpgradeInfo::paused_reason].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// use google_cloud_container_v1::model::cluster_upgrade_info::AutoUpgradePausedReason;
    /// let x = ClusterUpgradeInfo::new().set_paused_reason([
    ///     AutoUpgradePausedReason::MaintenanceWindow,
    ///     AutoUpgradePausedReason::MaintenanceExclusionNoUpgrades,
    ///     AutoUpgradePausedReason::MaintenanceExclusionNoMinorUpgrades,
    /// ]);
    /// ```
    pub fn set_paused_reason<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::cluster_upgrade_info::AutoUpgradePausedReason>,
    {
        use std::iter::Iterator;
        self.paused_reason = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [upgrade_details][crate::model::ClusterUpgradeInfo::upgrade_details].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// use google_cloud_container_v1::model::UpgradeDetails;
    /// let x = ClusterUpgradeInfo::new()
    ///     .set_upgrade_details([
    ///         UpgradeDetails::default()/* use setters */,
    ///         UpgradeDetails::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_upgrade_details<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::UpgradeDetails>,
    {
        use std::iter::Iterator;
        self.upgrade_details = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [end_of_standard_support_timestamp][crate::model::ClusterUpgradeInfo::end_of_standard_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_end_of_standard_support_timestamp("example");
    /// ```
    pub fn set_end_of_standard_support_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_standard_support_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_of_standard_support_timestamp][crate::model::ClusterUpgradeInfo::end_of_standard_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_or_clear_end_of_standard_support_timestamp(Some("example"));
    /// let x = ClusterUpgradeInfo::new().set_or_clear_end_of_standard_support_timestamp(None::<String>);
    /// ```
    pub fn set_or_clear_end_of_standard_support_timestamp<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_standard_support_timestamp = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_of_extended_support_timestamp][crate::model::ClusterUpgradeInfo::end_of_extended_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_end_of_extended_support_timestamp("example");
    /// ```
    pub fn set_end_of_extended_support_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_extended_support_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_of_extended_support_timestamp][crate::model::ClusterUpgradeInfo::end_of_extended_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ClusterUpgradeInfo;
    /// let x = ClusterUpgradeInfo::new().set_or_clear_end_of_extended_support_timestamp(Some("example"));
    /// let x = ClusterUpgradeInfo::new().set_or_clear_end_of_extended_support_timestamp(None::<String>);
    /// ```
    pub fn set_or_clear_end_of_extended_support_timestamp<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_extended_support_timestamp = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ClusterUpgradeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ClusterUpgradeInfo"
    }
}

/// Defines additional types related to [ClusterUpgradeInfo].
pub mod cluster_upgrade_info {
    #[allow(unused_imports)]
    use super::*;

    /// AutoUpgradeStatus indicates the status of auto upgrade.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutoUpgradeStatus {
        /// UNKNOWN indicates an unknown status.
        Unknown,
        /// ACTIVE indicates an active status.
        Active,
        /// MINOR_UPGRADE_PAUSED indicates the minor version upgrade is
        /// paused.
        MinorUpgradePaused,
        /// UPGRADE_PAUSED indicates the upgrade is paused.
        UpgradePaused,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutoUpgradeStatus::value] or
        /// [AutoUpgradeStatus::name].
        UnknownValue(auto_upgrade_status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod auto_upgrade_status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutoUpgradeStatus {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Active => std::option::Option::Some(1),
                Self::MinorUpgradePaused => std::option::Option::Some(4),
                Self::UpgradePaused => std::option::Option::Some(5),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::Active => std::option::Option::Some("ACTIVE"),
                Self::MinorUpgradePaused => std::option::Option::Some("MINOR_UPGRADE_PAUSED"),
                Self::UpgradePaused => std::option::Option::Some("UPGRADE_PAUSED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutoUpgradeStatus {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutoUpgradeStatus {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutoUpgradeStatus {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Active,
                4 => Self::MinorUpgradePaused,
                5 => Self::UpgradePaused,
                _ => Self::UnknownValue(auto_upgrade_status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutoUpgradeStatus {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "ACTIVE" => Self::Active,
                "MINOR_UPGRADE_PAUSED" => Self::MinorUpgradePaused,
                "UPGRADE_PAUSED" => Self::UpgradePaused,
                _ => Self::UnknownValue(auto_upgrade_status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutoUpgradeStatus {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Active => serializer.serialize_i32(1),
                Self::MinorUpgradePaused => serializer.serialize_i32(4),
                Self::UpgradePaused => serializer.serialize_i32(5),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutoUpgradeStatus {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<AutoUpgradeStatus>::new(
                ".google.container.v1.ClusterUpgradeInfo.AutoUpgradeStatus",
            ))
        }
    }

    /// AutoUpgradePausedReason indicates the reason for auto upgrade paused
    /// status.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutoUpgradePausedReason {
        /// AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED indicates an unspecified reason.
        Unspecified,
        /// MAINTENANCE_WINDOW indicates the cluster is outside customer maintenance
        /// window.
        MaintenanceWindow,
        /// MAINTENANCE_EXCLUSION_NO_UPGRADES indicates the cluster is in a
        /// maintenance exclusion with scope NO_UPGRADES.
        MaintenanceExclusionNoUpgrades,
        /// MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES indicates the cluster is in a
        /// maintenance exclusion with scope NO_MINOR_UPGRADES.
        MaintenanceExclusionNoMinorUpgrades,
        /// CLUSTER_DISRUPTION_BUDGET indicates the cluster is outside the cluster
        /// disruption budget.
        ClusterDisruptionBudget,
        /// CLUSTER_DISRUPTION_BUDGET_MINOR_UPGRADE indicates the cluster is outside
        /// the cluster disruption budget for minor version upgrade.
        ClusterDisruptionBudgetMinorUpgrade,
        /// SYSTEM_CONFIG indicates the cluster upgrade is paused  by system config.
        SystemConfig,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutoUpgradePausedReason::value] or
        /// [AutoUpgradePausedReason::name].
        UnknownValue(auto_upgrade_paused_reason::UnknownValue),
    }

    #[doc(hidden)]
    pub mod auto_upgrade_paused_reason {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutoUpgradePausedReason {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::MaintenanceWindow => std::option::Option::Some(1),
                Self::MaintenanceExclusionNoUpgrades => std::option::Option::Some(5),
                Self::MaintenanceExclusionNoMinorUpgrades => std::option::Option::Some(6),
                Self::ClusterDisruptionBudget => std::option::Option::Some(4),
                Self::ClusterDisruptionBudgetMinorUpgrade => std::option::Option::Some(7),
                Self::SystemConfig => std::option::Option::Some(8),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED")
                }
                Self::MaintenanceWindow => std::option::Option::Some("MAINTENANCE_WINDOW"),
                Self::MaintenanceExclusionNoUpgrades => {
                    std::option::Option::Some("MAINTENANCE_EXCLUSION_NO_UPGRADES")
                }
                Self::MaintenanceExclusionNoMinorUpgrades => {
                    std::option::Option::Some("MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES")
                }
                Self::ClusterDisruptionBudget => {
                    std::option::Option::Some("CLUSTER_DISRUPTION_BUDGET")
                }
                Self::ClusterDisruptionBudgetMinorUpgrade => {
                    std::option::Option::Some("CLUSTER_DISRUPTION_BUDGET_MINOR_UPGRADE")
                }
                Self::SystemConfig => std::option::Option::Some("SYSTEM_CONFIG"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutoUpgradePausedReason {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutoUpgradePausedReason {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutoUpgradePausedReason {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::MaintenanceWindow,
                4 => Self::ClusterDisruptionBudget,
                5 => Self::MaintenanceExclusionNoUpgrades,
                6 => Self::MaintenanceExclusionNoMinorUpgrades,
                7 => Self::ClusterDisruptionBudgetMinorUpgrade,
                8 => Self::SystemConfig,
                _ => Self::UnknownValue(auto_upgrade_paused_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutoUpgradePausedReason {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED" => Self::Unspecified,
                "MAINTENANCE_WINDOW" => Self::MaintenanceWindow,
                "MAINTENANCE_EXCLUSION_NO_UPGRADES" => Self::MaintenanceExclusionNoUpgrades,
                "MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES" => {
                    Self::MaintenanceExclusionNoMinorUpgrades
                }
                "CLUSTER_DISRUPTION_BUDGET" => Self::ClusterDisruptionBudget,
                "CLUSTER_DISRUPTION_BUDGET_MINOR_UPGRADE" => {
                    Self::ClusterDisruptionBudgetMinorUpgrade
                }
                "SYSTEM_CONFIG" => Self::SystemConfig,
                _ => Self::UnknownValue(auto_upgrade_paused_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutoUpgradePausedReason {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::MaintenanceWindow => serializer.serialize_i32(1),
                Self::MaintenanceExclusionNoUpgrades => serializer.serialize_i32(5),
                Self::MaintenanceExclusionNoMinorUpgrades => serializer.serialize_i32(6),
                Self::ClusterDisruptionBudget => serializer.serialize_i32(4),
                Self::ClusterDisruptionBudgetMinorUpgrade => serializer.serialize_i32(7),
                Self::SystemConfig => serializer.serialize_i32(8),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutoUpgradePausedReason {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<AutoUpgradePausedReason>::new(
                    ".google.container.v1.ClusterUpgradeInfo.AutoUpgradePausedReason",
                ),
            )
        }
    }
}

/// UpgradeDetails contains detailed information of each individual upgrade
/// operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpgradeDetails {
    /// Output only. The state of the upgrade.
    pub state: crate::model::upgrade_details::State,

    /// The start timestamp of the upgrade.
    pub start_time: std::option::Option<wkt::Timestamp>,

    /// The end timestamp of the upgrade.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// The version before the upgrade.
    pub initial_version: std::string::String,

    /// The version after the upgrade.
    pub target_version: std::string::String,

    /// The start type of the upgrade.
    pub start_type: crate::model::upgrade_details::StartType,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpgradeDetails {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [state][crate::model::UpgradeDetails::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use google_cloud_container_v1::model::upgrade_details::State;
    /// let x0 = UpgradeDetails::new().set_state(State::Failed);
    /// let x1 = UpgradeDetails::new().set_state(State::Succeeded);
    /// let x2 = UpgradeDetails::new().set_state(State::Canceled);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::upgrade_details::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [start_time][crate::model::UpgradeDetails::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use wkt::Timestamp;
    /// let x = UpgradeDetails::new().set_start_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_start_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [start_time][crate::model::UpgradeDetails::start_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use wkt::Timestamp;
    /// let x = UpgradeDetails::new().set_or_clear_start_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeDetails::new().set_or_clear_start_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_start_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.start_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::UpgradeDetails::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use wkt::Timestamp;
    /// let x = UpgradeDetails::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::UpgradeDetails::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use wkt::Timestamp;
    /// let x = UpgradeDetails::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = UpgradeDetails::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [initial_version][crate::model::UpgradeDetails::initial_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// let x = UpgradeDetails::new().set_initial_version("example");
    /// ```
    pub fn set_initial_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.initial_version = v.into();
        self
    }

    /// Sets the value of [target_version][crate::model::UpgradeDetails::target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// let x = UpgradeDetails::new().set_target_version("example");
    /// ```
    pub fn set_target_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target_version = v.into();
        self
    }

    /// Sets the value of [start_type][crate::model::UpgradeDetails::start_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::UpgradeDetails;
    /// use google_cloud_container_v1::model::upgrade_details::StartType;
    /// let x0 = UpgradeDetails::new().set_start_type(StartType::Automatic);
    /// let x1 = UpgradeDetails::new().set_start_type(StartType::Manual);
    /// ```
    pub fn set_start_type<T: std::convert::Into<crate::model::upgrade_details::StartType>>(
        mut self,
        v: T,
    ) -> Self {
        self.start_type = v.into();
        self
    }
}

impl wkt::message::Message for UpgradeDetails {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.UpgradeDetails"
    }
}

/// Defines additional types related to [UpgradeDetails].
pub mod upgrade_details {
    #[allow(unused_imports)]
    use super::*;

    /// State indicates the state of the upgrade.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Upgrade state is unknown.
        Unknown,
        /// Upgrade has failed with an error.
        Failed,
        /// Upgrade has succeeded.
        Succeeded,
        /// Upgrade has been canceled.
        Canceled,
        /// Upgrade is running.
        Running,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl State {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Failed => std::option::Option::Some(1),
                Self::Succeeded => std::option::Option::Some(2),
                Self::Canceled => std::option::Option::Some(3),
                Self::Running => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::Failed => std::option::Option::Some("FAILED"),
                Self::Succeeded => std::option::Option::Some("SUCCEEDED"),
                Self::Canceled => std::option::Option::Some("CANCELED"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for State {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for State {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Failed,
                2 => Self::Succeeded,
                3 => Self::Canceled,
                4 => Self::Running,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "FAILED" => Self::Failed,
                "SUCCEEDED" => Self::Succeeded,
                "CANCELED" => Self::Canceled,
                "RUNNING" => Self::Running,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Failed => serializer.serialize_i32(1),
                Self::Succeeded => serializer.serialize_i32(2),
                Self::Canceled => serializer.serialize_i32(3),
                Self::Running => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for State {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<State>::new(
                ".google.container.v1.UpgradeDetails.State",
            ))
        }
    }

    /// StartType indicates the type of starting the upgrade.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum StartType {
        /// Upgrade start type is unspecified.
        Unspecified,
        /// Upgrade started automatically.
        Automatic,
        /// Upgrade started manually.
        Manual,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [StartType::value] or
        /// [StartType::name].
        UnknownValue(start_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod start_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl StartType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Automatic => std::option::Option::Some(1),
                Self::Manual => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("START_TYPE_UNSPECIFIED"),
                Self::Automatic => std::option::Option::Some("AUTOMATIC"),
                Self::Manual => std::option::Option::Some("MANUAL"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for StartType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for StartType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for StartType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Automatic,
                2 => Self::Manual,
                _ => Self::UnknownValue(start_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for StartType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "START_TYPE_UNSPECIFIED" => Self::Unspecified,
                "AUTOMATIC" => Self::Automatic,
                "MANUAL" => Self::Manual,
                _ => Self::UnknownValue(start_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for StartType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Automatic => serializer.serialize_i32(1),
                Self::Manual => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for StartType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<StartType>::new(
                ".google.container.v1.UpgradeDetails.StartType",
            ))
        }
    }
}

/// FetchNodePoolUpgradeInfoRequest fetches the upgrade information of a
/// node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FetchNodePoolUpgradeInfoRequest {
    /// Required. The name (project, location, cluster, node pool) of the node pool
    /// to get. Specified in the format
    /// `projects/*/locations/*/clusters/*/nodePools/*` or
    /// `projects/*/zones/*/clusters/*/nodePools/*`.
    pub name: std::string::String,

    /// API request version that initiates this operation.
    pub version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl FetchNodePoolUpgradeInfoRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::FetchNodePoolUpgradeInfoRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::FetchNodePoolUpgradeInfoRequest;
    /// let x = FetchNodePoolUpgradeInfoRequest::new().set_name("example");
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [version][crate::model::FetchNodePoolUpgradeInfoRequest::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::FetchNodePoolUpgradeInfoRequest;
    /// let x = FetchNodePoolUpgradeInfoRequest::new().set_version("example");
    /// ```
    pub fn set_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.version = v.into();
        self
    }
}

impl wkt::message::Message for FetchNodePoolUpgradeInfoRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.FetchNodePoolUpgradeInfoRequest"
    }
}

/// NodePoolUpgradeInfo contains the upgrade information of a node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodePoolUpgradeInfo {
    /// minor_target_version indicates the target version for minor upgrade.
    pub minor_target_version: std::option::Option<std::string::String>,

    /// patch_target_version indicates the target version for patch upgrade.
    pub patch_target_version: std::option::Option<std::string::String>,

    /// The auto upgrade status.
    pub auto_upgrade_status: std::vec::Vec<crate::model::node_pool_upgrade_info::AutoUpgradeStatus>,

    /// The auto upgrade paused reason.
    pub paused_reason: std::vec::Vec<crate::model::node_pool_upgrade_info::AutoUpgradePausedReason>,

    /// The list of past auto upgrades.
    pub upgrade_details: std::vec::Vec<crate::model::UpgradeDetails>,

    /// The node pool's current minor version's end of standard support timestamp.
    pub end_of_standard_support_timestamp: std::option::Option<std::string::String>,

    /// The node pool's current minor version's end of extended support timestamp.
    pub end_of_extended_support_timestamp: std::option::Option<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NodePoolUpgradeInfo {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [minor_target_version][crate::model::NodePoolUpgradeInfo::minor_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_minor_target_version("example");
    /// ```
    pub fn set_minor_target_version<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.minor_target_version = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [minor_target_version][crate::model::NodePoolUpgradeInfo::minor_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_minor_target_version(Some("example"));
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_minor_target_version(None::<String>);
    /// ```
    pub fn set_or_clear_minor_target_version<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.minor_target_version = v.map(|x| x.into());
        self
    }

    /// Sets the value of [patch_target_version][crate::model::NodePoolUpgradeInfo::patch_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_patch_target_version("example");
    /// ```
    pub fn set_patch_target_version<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.patch_target_version = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [patch_target_version][crate::model::NodePoolUpgradeInfo::patch_target_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_patch_target_version(Some("example"));
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_patch_target_version(None::<String>);
    /// ```
    pub fn set_or_clear_patch_target_version<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.patch_target_version = v.map(|x| x.into());
        self
    }

    /// Sets the value of [auto_upgrade_status][crate::model::NodePoolUpgradeInfo::auto_upgrade_status].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// use google_cloud_container_v1::model::node_pool_upgrade_info::AutoUpgradeStatus;
    /// let x = NodePoolUpgradeInfo::new().set_auto_upgrade_status([
    ///     AutoUpgradeStatus::Active,
    ///     AutoUpgradeStatus::MinorUpgradePaused,
    ///     AutoUpgradeStatus::UpgradePaused,
    /// ]);
    /// ```
    pub fn set_auto_upgrade_status<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::node_pool_upgrade_info::AutoUpgradeStatus>,
    {
        use std::iter::Iterator;
        self.auto_upgrade_status = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [paused_reason][crate::model::NodePoolUpgradeInfo::paused_reason].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// use google_cloud_container_v1::model::node_pool_upgrade_info::AutoUpgradePausedReason;
    /// let x = NodePoolUpgradeInfo::new().set_paused_reason([
    ///     AutoUpgradePausedReason::MaintenanceWindow,
    ///     AutoUpgradePausedReason::MaintenanceExclusionNoUpgrades,
    ///     AutoUpgradePausedReason::MaintenanceExclusionNoMinorUpgrades,
    /// ]);
    /// ```
    pub fn set_paused_reason<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::node_pool_upgrade_info::AutoUpgradePausedReason>,
    {
        use std::iter::Iterator;
        self.paused_reason = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [upgrade_details][crate::model::NodePoolUpgradeInfo::upgrade_details].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// use google_cloud_container_v1::model::UpgradeDetails;
    /// let x = NodePoolUpgradeInfo::new()
    ///     .set_upgrade_details([
    ///         UpgradeDetails::default()/* use setters */,
    ///         UpgradeDetails::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_upgrade_details<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::UpgradeDetails>,
    {
        use std::iter::Iterator;
        self.upgrade_details = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [end_of_standard_support_timestamp][crate::model::NodePoolUpgradeInfo::end_of_standard_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_end_of_standard_support_timestamp("example");
    /// ```
    pub fn set_end_of_standard_support_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_standard_support_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_of_standard_support_timestamp][crate::model::NodePoolUpgradeInfo::end_of_standard_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_end_of_standard_support_timestamp(Some("example"));
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_end_of_standard_support_timestamp(None::<String>);
    /// ```
    pub fn set_or_clear_end_of_standard_support_timestamp<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_standard_support_timestamp = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_of_extended_support_timestamp][crate::model::NodePoolUpgradeInfo::end_of_extended_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_end_of_extended_support_timestamp("example");
    /// ```
    pub fn set_end_of_extended_support_timestamp<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_extended_support_timestamp = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_of_extended_support_timestamp][crate::model::NodePoolUpgradeInfo::end_of_extended_support_timestamp].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NodePoolUpgradeInfo;
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_end_of_extended_support_timestamp(Some("example"));
    /// let x = NodePoolUpgradeInfo::new().set_or_clear_end_of_extended_support_timestamp(None::<String>);
    /// ```
    pub fn set_or_clear_end_of_extended_support_timestamp<T>(
        mut self,
        v: std::option::Option<T>,
    ) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.end_of_extended_support_timestamp = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for NodePoolUpgradeInfo {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NodePoolUpgradeInfo"
    }
}

/// Defines additional types related to [NodePoolUpgradeInfo].
pub mod node_pool_upgrade_info {
    #[allow(unused_imports)]
    use super::*;

    /// AutoUpgradeStatus indicates the status of auto upgrade.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutoUpgradeStatus {
        /// UNKNOWN indicates an unknown status.
        Unknown,
        /// ACTIVE indicates an active status.
        Active,
        /// MINOR_UPGRADE_PAUSED indicates the minor version upgrade is
        /// paused.
        MinorUpgradePaused,
        /// UPGRADE_PAUSED indicates the upgrade is paused.
        UpgradePaused,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutoUpgradeStatus::value] or
        /// [AutoUpgradeStatus::name].
        UnknownValue(auto_upgrade_status::UnknownValue),
    }

    #[doc(hidden)]
    pub mod auto_upgrade_status {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutoUpgradeStatus {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unknown => std::option::Option::Some(0),
                Self::Active => std::option::Option::Some(1),
                Self::MinorUpgradePaused => std::option::Option::Some(2),
                Self::UpgradePaused => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unknown => std::option::Option::Some("UNKNOWN"),
                Self::Active => std::option::Option::Some("ACTIVE"),
                Self::MinorUpgradePaused => std::option::Option::Some("MINOR_UPGRADE_PAUSED"),
                Self::UpgradePaused => std::option::Option::Some("UPGRADE_PAUSED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutoUpgradeStatus {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutoUpgradeStatus {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutoUpgradeStatus {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unknown,
                1 => Self::Active,
                2 => Self::MinorUpgradePaused,
                3 => Self::UpgradePaused,
                _ => Self::UnknownValue(auto_upgrade_status::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutoUpgradeStatus {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "UNKNOWN" => Self::Unknown,
                "ACTIVE" => Self::Active,
                "MINOR_UPGRADE_PAUSED" => Self::MinorUpgradePaused,
                "UPGRADE_PAUSED" => Self::UpgradePaused,
                _ => Self::UnknownValue(auto_upgrade_status::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutoUpgradeStatus {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unknown => serializer.serialize_i32(0),
                Self::Active => serializer.serialize_i32(1),
                Self::MinorUpgradePaused => serializer.serialize_i32(2),
                Self::UpgradePaused => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutoUpgradeStatus {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<AutoUpgradeStatus>::new(
                ".google.container.v1.NodePoolUpgradeInfo.AutoUpgradeStatus",
            ))
        }
    }

    /// AutoUpgradePausedReason indicates the reason for auto upgrade paused
    /// status.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum AutoUpgradePausedReason {
        /// AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED indicates an unspecified reason.
        Unspecified,
        /// MAINTENANCE_WINDOW indicates the cluster is outside customer maintenance
        /// window.
        MaintenanceWindow,
        /// MAINTENANCE_EXCLUSION_NO_UPGRADES indicates the cluster is in a
        /// maintenance exclusion with scope NO_UPGRADES.
        MaintenanceExclusionNoUpgrades,
        /// MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES indicates the cluster is in a
        /// maintenance exclusion with scope NO_MINOR_UPGRADES.
        MaintenanceExclusionNoMinorUpgrades,
        /// SYSTEM_CONFIG indicates the cluster upgrade is paused by system config.
        SystemConfig,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [AutoUpgradePausedReason::value] or
        /// [AutoUpgradePausedReason::name].
        UnknownValue(auto_upgrade_paused_reason::UnknownValue),
    }

    #[doc(hidden)]
    pub mod auto_upgrade_paused_reason {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl AutoUpgradePausedReason {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::MaintenanceWindow => std::option::Option::Some(1),
                Self::MaintenanceExclusionNoUpgrades => std::option::Option::Some(2),
                Self::MaintenanceExclusionNoMinorUpgrades => std::option::Option::Some(3),
                Self::SystemConfig => std::option::Option::Some(4),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => {
                    std::option::Option::Some("AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED")
                }
                Self::MaintenanceWindow => std::option::Option::Some("MAINTENANCE_WINDOW"),
                Self::MaintenanceExclusionNoUpgrades => {
                    std::option::Option::Some("MAINTENANCE_EXCLUSION_NO_UPGRADES")
                }
                Self::MaintenanceExclusionNoMinorUpgrades => {
                    std::option::Option::Some("MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES")
                }
                Self::SystemConfig => std::option::Option::Some("SYSTEM_CONFIG"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for AutoUpgradePausedReason {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for AutoUpgradePausedReason {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for AutoUpgradePausedReason {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::MaintenanceWindow,
                2 => Self::MaintenanceExclusionNoUpgrades,
                3 => Self::MaintenanceExclusionNoMinorUpgrades,
                4 => Self::SystemConfig,
                _ => Self::UnknownValue(auto_upgrade_paused_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for AutoUpgradePausedReason {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "AUTO_UPGRADE_PAUSED_REASON_UNSPECIFIED" => Self::Unspecified,
                "MAINTENANCE_WINDOW" => Self::MaintenanceWindow,
                "MAINTENANCE_EXCLUSION_NO_UPGRADES" => Self::MaintenanceExclusionNoUpgrades,
                "MAINTENANCE_EXCLUSION_NO_MINOR_UPGRADES" => {
                    Self::MaintenanceExclusionNoMinorUpgrades
                }
                "SYSTEM_CONFIG" => Self::SystemConfig,
                _ => Self::UnknownValue(auto_upgrade_paused_reason::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for AutoUpgradePausedReason {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::MaintenanceWindow => serializer.serialize_i32(1),
                Self::MaintenanceExclusionNoUpgrades => serializer.serialize_i32(2),
                Self::MaintenanceExclusionNoMinorUpgrades => serializer.serialize_i32(3),
                Self::SystemConfig => serializer.serialize_i32(4),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for AutoUpgradePausedReason {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(
                wkt::internal::EnumVisitor::<AutoUpgradePausedReason>::new(
                    ".google.container.v1.NodePoolUpgradeInfo.AutoUpgradePausedReason",
                ),
            )
        }
    }
}

/// Configuration for scheduled upgrades on the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ScheduleUpgradeConfig {
    /// Optional. Whether or not scheduled upgrades are enabled.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ScheduleUpgradeConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ScheduleUpgradeConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ScheduleUpgradeConfig;
    /// let x = ScheduleUpgradeConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for ScheduleUpgradeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ScheduleUpgradeConfig"
    }
}

/// GkeAutoUpgradeConfig is the configuration for GKE auto upgrades.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GkeAutoUpgradeConfig {
    /// PatchMode specifies how auto upgrade patch builds should be
    /// selected.
    pub patch_mode: crate::model::gke_auto_upgrade_config::PatchMode,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GkeAutoUpgradeConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [patch_mode][crate::model::GkeAutoUpgradeConfig::patch_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::GkeAutoUpgradeConfig;
    /// use google_cloud_container_v1::model::gke_auto_upgrade_config::PatchMode;
    /// let x0 = GkeAutoUpgradeConfig::new().set_patch_mode(PatchMode::Accelerated);
    /// ```
    pub fn set_patch_mode<
        T: std::convert::Into<crate::model::gke_auto_upgrade_config::PatchMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.patch_mode = v.into();
        self
    }
}

impl wkt::message::Message for GkeAutoUpgradeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.GkeAutoUpgradeConfig"
    }
}

/// Defines additional types related to [GkeAutoUpgradeConfig].
pub mod gke_auto_upgrade_config {
    #[allow(unused_imports)]
    use super::*;

    /// PatchMode specifies how auto upgrade patch builds should be
    /// selected.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum PatchMode {
        /// PATCH_MODE_UNSPECIFIED defaults to using the upgrade target from the
        /// channel's patch upgrade targets as the upgrade target for the
        /// version.
        Unspecified,
        /// ACCELERATED denotes that the latest patch build in the channel should be
        /// used as the upgrade target for the version.
        Accelerated,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [PatchMode::value] or
        /// [PatchMode::name].
        UnknownValue(patch_mode::UnknownValue),
    }

    #[doc(hidden)]
    pub mod patch_mode {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl PatchMode {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Accelerated => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("PATCH_MODE_UNSPECIFIED"),
                Self::Accelerated => std::option::Option::Some("ACCELERATED"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for PatchMode {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for PatchMode {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for PatchMode {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Accelerated,
                _ => Self::UnknownValue(patch_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for PatchMode {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PATCH_MODE_UNSPECIFIED" => Self::Unspecified,
                "ACCELERATED" => Self::Accelerated,
                _ => Self::UnknownValue(patch_mode::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for PatchMode {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Accelerated => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for PatchMode {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<PatchMode>::new(
                ".google.container.v1.GkeAutoUpgradeConfig.PatchMode",
            ))
        }
    }
}

/// NetworkTierConfig contains network tier information.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkTierConfig {
    /// Network tier configuration.
    pub network_tier: crate::model::network_tier_config::NetworkTier,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl NetworkTierConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [network_tier][crate::model::NetworkTierConfig::network_tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::NetworkTierConfig;
    /// use google_cloud_container_v1::model::network_tier_config::NetworkTier;
    /// let x0 = NetworkTierConfig::new().set_network_tier(NetworkTier::Default);
    /// let x1 = NetworkTierConfig::new().set_network_tier(NetworkTier::Premium);
    /// let x2 = NetworkTierConfig::new().set_network_tier(NetworkTier::Standard);
    /// ```
    pub fn set_network_tier<
        T: std::convert::Into<crate::model::network_tier_config::NetworkTier>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.network_tier = v.into();
        self
    }
}

impl wkt::message::Message for NetworkTierConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.NetworkTierConfig"
    }
}

/// Defines additional types related to [NetworkTierConfig].
pub mod network_tier_config {
    #[allow(unused_imports)]
    use super::*;

    /// Network tier configuration.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum NetworkTier {
        /// By default, use project-level configuration. When unspecified, the
        /// behavior defaults to NETWORK_TIER_DEFAULT. For cluster updates, this
        /// implies no action (no-op).
        Unspecified,
        /// Default network tier. Use project-level configuration. User can specify
        /// this value, meaning they want to keep the same behaviour as before
        /// cluster level network tier configuration is introduced. This field
        /// ensures backward compatibility for the network tier of cluster resources,
        /// such as node pools and load balancers, for their external IP addresses.
        Default,
        /// Premium network tier.
        Premium,
        /// Standard network tier.
        Standard,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [NetworkTier::value] or
        /// [NetworkTier::name].
        UnknownValue(network_tier::UnknownValue),
    }

    #[doc(hidden)]
    pub mod network_tier {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl NetworkTier {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Default => std::option::Option::Some(1),
                Self::Premium => std::option::Option::Some(2),
                Self::Standard => std::option::Option::Some(3),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("NETWORK_TIER_UNSPECIFIED"),
                Self::Default => std::option::Option::Some("NETWORK_TIER_DEFAULT"),
                Self::Premium => std::option::Option::Some("NETWORK_TIER_PREMIUM"),
                Self::Standard => std::option::Option::Some("NETWORK_TIER_STANDARD"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for NetworkTier {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for NetworkTier {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for NetworkTier {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Default,
                2 => Self::Premium,
                3 => Self::Standard,
                _ => Self::UnknownValue(network_tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for NetworkTier {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "NETWORK_TIER_UNSPECIFIED" => Self::Unspecified,
                "NETWORK_TIER_DEFAULT" => Self::Default,
                "NETWORK_TIER_PREMIUM" => Self::Premium,
                "NETWORK_TIER_STANDARD" => Self::Standard,
                _ => Self::UnknownValue(network_tier::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for NetworkTier {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Default => serializer.serialize_i32(1),
                Self::Premium => serializer.serialize_i32(2),
                Self::Standard => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for NetworkTier {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<NetworkTier>::new(
                ".google.container.v1.NetworkTierConfig.NetworkTier",
            ))
        }
    }
}

/// Configuration for sync Secret Manager secrets as k8s secrets.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SecretSyncConfig {
    /// Enable/Disable Secret Sync Config.
    pub enabled: std::option::Option<bool>,

    /// Rotation config for secret manager.
    pub rotation_config: std::option::Option<crate::model::secret_sync_config::SyncRotationConfig>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl SecretSyncConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::SecretSyncConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = SecretSyncConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enabled][crate::model::SecretSyncConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretSyncConfig;
    /// let x = SecretSyncConfig::new().set_or_clear_enabled(Some(false));
    /// let x = SecretSyncConfig::new().set_or_clear_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = v.map(|x| x.into());
        self
    }

    /// Sets the value of [rotation_config][crate::model::SecretSyncConfig::rotation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretSyncConfig;
    /// use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
    /// let x = SecretSyncConfig::new().set_rotation_config(SyncRotationConfig::default()/* use setters */);
    /// ```
    pub fn set_rotation_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::secret_sync_config::SyncRotationConfig>,
    {
        self.rotation_config = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [rotation_config][crate::model::SecretSyncConfig::rotation_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::SecretSyncConfig;
    /// use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
    /// let x = SecretSyncConfig::new().set_or_clear_rotation_config(Some(SyncRotationConfig::default()/* use setters */));
    /// let x = SecretSyncConfig::new().set_or_clear_rotation_config(None::<SyncRotationConfig>);
    /// ```
    pub fn set_or_clear_rotation_config<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::secret_sync_config::SyncRotationConfig>,
    {
        self.rotation_config = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for SecretSyncConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.SecretSyncConfig"
    }
}

/// Defines additional types related to [SecretSyncConfig].
pub mod secret_sync_config {
    #[allow(unused_imports)]
    use super::*;

    /// SyncRotationConfig is config for secret manager auto rotation.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct SyncRotationConfig {
        /// Whether the rotation is enabled.
        pub enabled: std::option::Option<bool>,

        /// The interval between two consecutive rotations. Default rotation interval
        /// is 2 minutes.
        pub rotation_interval: std::option::Option<wkt::Duration>,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl SyncRotationConfig {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [enabled][crate::model::secret_sync_config::SyncRotationConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
        /// let x = SyncRotationConfig::new().set_enabled(true);
        /// ```
        pub fn set_enabled<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [enabled][crate::model::secret_sync_config::SyncRotationConfig::enabled].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
        /// let x = SyncRotationConfig::new().set_or_clear_enabled(Some(false));
        /// let x = SyncRotationConfig::new().set_or_clear_enabled(None::<bool>);
        /// ```
        pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.enabled = v.map(|x| x.into());
            self
        }

        /// Sets the value of [rotation_interval][crate::model::secret_sync_config::SyncRotationConfig::rotation_interval].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
        /// use wkt::Duration;
        /// let x = SyncRotationConfig::new().set_rotation_interval(Duration::default()/* use setters */);
        /// ```
        pub fn set_rotation_interval<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.rotation_interval = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [rotation_interval][crate::model::secret_sync_config::SyncRotationConfig::rotation_interval].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_container_v1::model::secret_sync_config::SyncRotationConfig;
        /// use wkt::Duration;
        /// let x = SyncRotationConfig::new().set_or_clear_rotation_interval(Some(Duration::default()/* use setters */));
        /// let x = SyncRotationConfig::new().set_or_clear_rotation_interval(None::<Duration>);
        /// ```
        pub fn set_or_clear_rotation_interval<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<wkt::Duration>,
        {
            self.rotation_interval = v.map(|x| x.into());
            self
        }
    }

    impl wkt::message::Message for SyncRotationConfig {
        fn typename() -> &'static str {
            "type.googleapis.com/google.container.v1.SecretSyncConfig.SyncRotationConfig"
        }
    }
}

/// ManagedOpenTelemetryConfig is the configuration for the GKE Managed
/// OpenTelemetry pipeline.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ManagedOpenTelemetryConfig {
    /// Scope of the Managed OpenTelemetry pipeline.
    pub scope: std::option::Option<crate::model::managed_open_telemetry_config::Scope>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ManagedOpenTelemetryConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [scope][crate::model::ManagedOpenTelemetryConfig::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// use google_cloud_container_v1::model::managed_open_telemetry_config::Scope;
    /// let x0 = ManagedOpenTelemetryConfig::new().set_scope(Scope::None);
    /// let x1 = ManagedOpenTelemetryConfig::new().set_scope(Scope::CollectionAndInstrumentationComponents);
    /// ```
    pub fn set_scope<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::managed_open_telemetry_config::Scope>,
    {
        self.scope = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [scope][crate::model::ManagedOpenTelemetryConfig::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedOpenTelemetryConfig;
    /// use google_cloud_container_v1::model::managed_open_telemetry_config::Scope;
    /// let x0 = ManagedOpenTelemetryConfig::new().set_or_clear_scope(Some(Scope::None));
    /// let x1 = ManagedOpenTelemetryConfig::new().set_or_clear_scope(Some(Scope::CollectionAndInstrumentationComponents));
    /// let x_none = ManagedOpenTelemetryConfig::new().set_or_clear_scope(None::<Scope>);
    /// ```
    pub fn set_or_clear_scope<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::managed_open_telemetry_config::Scope>,
    {
        self.scope = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ManagedOpenTelemetryConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ManagedOpenTelemetryConfig"
    }
}

/// Defines additional types related to [ManagedOpenTelemetryConfig].
pub mod managed_open_telemetry_config {
    #[allow(unused_imports)]
    use super::*;

    /// Scope is the scope of the Managed OpenTelemetry pipeline.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Scope {
        /// SCOPE_UNSPECIFIED is when the scope is not set.
        Unspecified,
        /// NONE is used to disable the Managed OpenTelemetry pipeline.
        None,
        /// COLLECTION_AND_INSTRUMENTATION_COMPONENTS is used to enable the Managed
        /// OpenTelemetry pipeline for collection and instrumentation components.
        CollectionAndInstrumentationComponents,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Scope::value] or
        /// [Scope::name].
        UnknownValue(scope::UnknownValue),
    }

    #[doc(hidden)]
    pub mod scope {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl Scope {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::None => std::option::Option::Some(1),
                Self::CollectionAndInstrumentationComponents => std::option::Option::Some(2),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("SCOPE_UNSPECIFIED"),
                Self::None => std::option::Option::Some("NONE"),
                Self::CollectionAndInstrumentationComponents => {
                    std::option::Option::Some("COLLECTION_AND_INSTRUMENTATION_COMPONENTS")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for Scope {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for Scope {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for Scope {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::None,
                2 => Self::CollectionAndInstrumentationComponents,
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Scope {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "SCOPE_UNSPECIFIED" => Self::Unspecified,
                "NONE" => Self::None,
                "COLLECTION_AND_INSTRUMENTATION_COMPONENTS" => {
                    Self::CollectionAndInstrumentationComponents
                }
                _ => Self::UnknownValue(scope::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Scope {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::None => serializer.serialize_i32(1),
                Self::CollectionAndInstrumentationComponents => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for Scope {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<Scope>::new(
                ".google.container.v1.ManagedOpenTelemetryConfig.Scope",
            ))
        }
    }
}

/// ManagedMachineLearningDiagnosticsConfig is the configuration for the GKE
/// Managed Machine Learning Diagnostics pipeline.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ManagedMachineLearningDiagnosticsConfig {
    /// Enable/Disable Managed Machine Learning Diagnostics.
    pub enabled: std::option::Option<bool>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ManagedMachineLearningDiagnosticsConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ManagedMachineLearningDiagnosticsConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = ManagedMachineLearningDiagnosticsConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [enabled][crate::model::ManagedMachineLearningDiagnosticsConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::ManagedMachineLearningDiagnosticsConfig;
    /// let x = ManagedMachineLearningDiagnosticsConfig::new().set_or_clear_enabled(Some(false));
    /// let x = ManagedMachineLearningDiagnosticsConfig::new().set_or_clear_enabled(None::<bool>);
    /// ```
    pub fn set_or_clear_enabled<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        self.enabled = v.map(|x| x.into());
        self
    }
}

impl wkt::message::Message for ManagedMachineLearningDiagnosticsConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.ManagedMachineLearningDiagnosticsConfig"
    }
}

/// PodSnapshotConfig is the configuration for GKE Pod Snapshots feature.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct PodSnapshotConfig {
    /// Whether or not the Pod Snapshots feature is enabled.
    pub enabled: bool,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl PodSnapshotConfig {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::PodSnapshotConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_container_v1::model::PodSnapshotConfig;
    /// let x = PodSnapshotConfig::new().set_enabled(true);
    /// ```
    pub fn set_enabled<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.enabled = v.into();
        self
    }
}

impl wkt::message::Message for PodSnapshotConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.container.v1.PodSnapshotConfig"
    }
}

/// PrivateIPv6GoogleAccess controls whether and how the pods can communicate
/// with Google Services through gRPC over IPv6.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum PrivateIPv6GoogleAccess {
    /// Default value. Same as DISABLED
    PrivateIpv6GoogleAccessUnspecified,
    /// No private access to or from Google Services
    PrivateIpv6GoogleAccessDisabled,
    /// Enables private IPv6 access to Google Services from GKE
    PrivateIpv6GoogleAccessToGoogle,
    /// Enables private IPv6 access to and from Google Services
    PrivateIpv6GoogleAccessBidirectional,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [PrivateIPv6GoogleAccess::value] or
    /// [PrivateIPv6GoogleAccess::name].
    UnknownValue(private_i_pv_6_google_access::UnknownValue),
}

#[doc(hidden)]
pub mod private_i_pv_6_google_access {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl PrivateIPv6GoogleAccess {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::PrivateIpv6GoogleAccessUnspecified => std::option::Option::Some(0),
            Self::PrivateIpv6GoogleAccessDisabled => std::option::Option::Some(1),
            Self::PrivateIpv6GoogleAccessToGoogle => std::option::Option::Some(2),
            Self::PrivateIpv6GoogleAccessBidirectional => std::option::Option::Some(3),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::PrivateIpv6GoogleAccessUnspecified => {
                std::option::Option::Some("PRIVATE_IPV6_GOOGLE_ACCESS_UNSPECIFIED")
            }
            Self::PrivateIpv6GoogleAccessDisabled => {
                std::option::Option::Some("PRIVATE_IPV6_GOOGLE_ACCESS_DISABLED")
            }
            Self::PrivateIpv6GoogleAccessToGoogle => {
                std::option::Option::Some("PRIVATE_IPV6_GOOGLE_ACCESS_TO_GOOGLE")
            }
            Self::PrivateIpv6GoogleAccessBidirectional => {
                std::option::Option::Some("PRIVATE_IPV6_GOOGLE_ACCESS_BIDIRECTIONAL")
            }
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for PrivateIPv6GoogleAccess {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for PrivateIPv6GoogleAccess {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for PrivateIPv6GoogleAccess {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::PrivateIpv6GoogleAccessUnspecified,
            1 => Self::PrivateIpv6GoogleAccessDisabled,
            2 => Self::PrivateIpv6GoogleAccessToGoogle,
            3 => Self::PrivateIpv6GoogleAccessBidirectional,
            _ => Self::UnknownValue(private_i_pv_6_google_access::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for PrivateIPv6GoogleAccess {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "PRIVATE_IPV6_GOOGLE_ACCESS_UNSPECIFIED" => Self::PrivateIpv6GoogleAccessUnspecified,
            "PRIVATE_IPV6_GOOGLE_ACCESS_DISABLED" => Self::PrivateIpv6GoogleAccessDisabled,
            "PRIVATE_IPV6_GOOGLE_ACCESS_TO_GOOGLE" => Self::PrivateIpv6GoogleAccessToGoogle,
            "PRIVATE_IPV6_GOOGLE_ACCESS_BIDIRECTIONAL" => {
                Self::PrivateIpv6GoogleAccessBidirectional
            }
            _ => Self::UnknownValue(private_i_pv_6_google_access::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for PrivateIPv6GoogleAccess {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::PrivateIpv6GoogleAccessUnspecified => serializer.serialize_i32(0),
            Self::PrivateIpv6GoogleAccessDisabled => serializer.serialize_i32(1),
            Self::PrivateIpv6GoogleAccessToGoogle => serializer.serialize_i32(2),
            Self::PrivateIpv6GoogleAccessBidirectional => serializer.serialize_i32(3),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for PrivateIPv6GoogleAccess {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<PrivateIPv6GoogleAccess>::new(
            ".google.container.v1.PrivateIPv6GoogleAccess",
        ))
    }
}

/// UpgradeResourceType is the resource type that is upgrading. It is used
/// in upgrade notifications.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum UpgradeResourceType {
    /// Default value. This shouldn't be used.
    Unspecified,
    /// Master / control plane
    Master,
    /// Node pool
    NodePool,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [UpgradeResourceType::value] or
    /// [UpgradeResourceType::name].
    UnknownValue(upgrade_resource_type::UnknownValue),
}

#[doc(hidden)]
pub mod upgrade_resource_type {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl UpgradeResourceType {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::Master => std::option::Option::Some(1),
            Self::NodePool => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("UPGRADE_RESOURCE_TYPE_UNSPECIFIED"),
            Self::Master => std::option::Option::Some("MASTER"),
            Self::NodePool => std::option::Option::Some("NODE_POOL"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for UpgradeResourceType {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for UpgradeResourceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for UpgradeResourceType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Master,
            2 => Self::NodePool,
            _ => Self::UnknownValue(upgrade_resource_type::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for UpgradeResourceType {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "UPGRADE_RESOURCE_TYPE_UNSPECIFIED" => Self::Unspecified,
            "MASTER" => Self::Master,
            "NODE_POOL" => Self::NodePool,
            _ => Self::UnknownValue(upgrade_resource_type::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for UpgradeResourceType {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::Master => serializer.serialize_i32(1),
            Self::NodePool => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for UpgradeResourceType {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<UpgradeResourceType>::new(
            ".google.container.v1.UpgradeResourceType",
        ))
    }
}

/// The datapath provider selects the implementation of the Kubernetes networking
/// model for service resolution and network policy enforcement.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum DatapathProvider {
    /// Default value.
    Unspecified,
    /// Use the IPTables implementation based on kube-proxy.
    LegacyDatapath,
    /// Use the eBPF based GKE Dataplane V2 with additional features. See the [GKE
    /// Dataplane V2
    /// documentation](https://cloud.google.com/kubernetes-engine/docs/how-to/dataplane-v2)
    /// for more.
    AdvancedDatapath,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [DatapathProvider::value] or
    /// [DatapathProvider::name].
    UnknownValue(datapath_provider::UnknownValue),
}

#[doc(hidden)]
pub mod datapath_provider {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl DatapathProvider {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::LegacyDatapath => std::option::Option::Some(1),
            Self::AdvancedDatapath => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("DATAPATH_PROVIDER_UNSPECIFIED"),
            Self::LegacyDatapath => std::option::Option::Some("LEGACY_DATAPATH"),
            Self::AdvancedDatapath => std::option::Option::Some("ADVANCED_DATAPATH"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for DatapathProvider {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for DatapathProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for DatapathProvider {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::LegacyDatapath,
            2 => Self::AdvancedDatapath,
            _ => Self::UnknownValue(datapath_provider::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for DatapathProvider {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "DATAPATH_PROVIDER_UNSPECIFIED" => Self::Unspecified,
            "LEGACY_DATAPATH" => Self::LegacyDatapath,
            "ADVANCED_DATAPATH" => Self::AdvancedDatapath,
            _ => Self::UnknownValue(datapath_provider::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for DatapathProvider {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::LegacyDatapath => serializer.serialize_i32(1),
            Self::AdvancedDatapath => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for DatapathProvider {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<DatapathProvider>::new(
            ".google.container.v1.DatapathProvider",
        ))
    }
}

/// Strategy used for node pool update.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum NodePoolUpdateStrategy {
    /// Default value if unset. GKE internally defaults the update strategy to
    /// SURGE for unspecified strategies.
    Unspecified,
    /// blue-green upgrade.
    BlueGreen,
    /// SURGE is the traditional way of upgrade a node pool.
    /// max_surge and max_unavailable determines the level of upgrade parallelism.
    Surge,
    /// SHORT_LIVED is the dedicated upgrade strategy for
    /// QueuedProvisioning and flex start node pools scaled up only by enqueueing
    /// to the Dynamic Workload Scheduler (DWS).
    ShortLived,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [NodePoolUpdateStrategy::value] or
    /// [NodePoolUpdateStrategy::name].
    UnknownValue(node_pool_update_strategy::UnknownValue),
}

#[doc(hidden)]
pub mod node_pool_update_strategy {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl NodePoolUpdateStrategy {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::BlueGreen => std::option::Option::Some(2),
            Self::Surge => std::option::Option::Some(3),
            Self::ShortLived => std::option::Option::Some(5),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("NODE_POOL_UPDATE_STRATEGY_UNSPECIFIED"),
            Self::BlueGreen => std::option::Option::Some("BLUE_GREEN"),
            Self::Surge => std::option::Option::Some("SURGE"),
            Self::ShortLived => std::option::Option::Some("SHORT_LIVED"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for NodePoolUpdateStrategy {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for NodePoolUpdateStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for NodePoolUpdateStrategy {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            2 => Self::BlueGreen,
            3 => Self::Surge,
            5 => Self::ShortLived,
            _ => Self::UnknownValue(node_pool_update_strategy::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for NodePoolUpdateStrategy {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "NODE_POOL_UPDATE_STRATEGY_UNSPECIFIED" => Self::Unspecified,
            "BLUE_GREEN" => Self::BlueGreen,
            "SURGE" => Self::Surge,
            "SHORT_LIVED" => Self::ShortLived,
            _ => Self::UnknownValue(node_pool_update_strategy::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for NodePoolUpdateStrategy {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::BlueGreen => serializer.serialize_i32(2),
            Self::Surge => serializer.serialize_i32(3),
            Self::ShortLived => serializer.serialize_i32(5),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for NodePoolUpdateStrategy {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<NodePoolUpdateStrategy>::new(
            ".google.container.v1.NodePoolUpdateStrategy",
        ))
    }
}

/// Possible values for IP stack type
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum StackType {
    /// Default value, will be defaulted as IPV4 only
    Unspecified,
    /// Cluster is IPV4 only
    Ipv4,
    /// Cluster can use both IPv4 and IPv6
    Ipv4Ipv6,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [StackType::value] or
    /// [StackType::name].
    UnknownValue(stack_type::UnknownValue),
}

#[doc(hidden)]
pub mod stack_type {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl StackType {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::Ipv4 => std::option::Option::Some(1),
            Self::Ipv4Ipv6 => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => std::option::Option::Some("STACK_TYPE_UNSPECIFIED"),
            Self::Ipv4 => std::option::Option::Some("IPV4"),
            Self::Ipv4Ipv6 => std::option::Option::Some("IPV4_IPV6"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for StackType {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for StackType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for StackType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::Ipv4,
            2 => Self::Ipv4Ipv6,
            _ => Self::UnknownValue(stack_type::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for StackType {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "STACK_TYPE_UNSPECIFIED" => Self::Unspecified,
            "IPV4" => Self::Ipv4,
            "IPV4_IPV6" => Self::Ipv4Ipv6,
            _ => Self::UnknownValue(stack_type::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for StackType {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::Ipv4 => serializer.serialize_i32(1),
            Self::Ipv4Ipv6 => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for StackType {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<StackType>::new(
            ".google.container.v1.StackType",
        ))
    }
}

/// Possible values for IPv6 access type
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum IPv6AccessType {
    /// Default value, will be defaulted as type external.
    Ipv6AccessTypeUnspecified,
    /// Access type internal (all v6 addresses are internal IPs)
    Internal,
    /// Access type external (all v6 addresses are external IPs)
    External,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [IPv6AccessType::value] or
    /// [IPv6AccessType::name].
    UnknownValue(i_pv_6_access_type::UnknownValue),
}

#[doc(hidden)]
pub mod i_pv_6_access_type {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl IPv6AccessType {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Ipv6AccessTypeUnspecified => std::option::Option::Some(0),
            Self::Internal => std::option::Option::Some(1),
            Self::External => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Ipv6AccessTypeUnspecified => {
                std::option::Option::Some("IPV6_ACCESS_TYPE_UNSPECIFIED")
            }
            Self::Internal => std::option::Option::Some("INTERNAL"),
            Self::External => std::option::Option::Some("EXTERNAL"),
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for IPv6AccessType {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for IPv6AccessType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for IPv6AccessType {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Ipv6AccessTypeUnspecified,
            1 => Self::Internal,
            2 => Self::External,
            _ => Self::UnknownValue(i_pv_6_access_type::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for IPv6AccessType {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "IPV6_ACCESS_TYPE_UNSPECIFIED" => Self::Ipv6AccessTypeUnspecified,
            "INTERNAL" => Self::Internal,
            "EXTERNAL" => Self::External,
            _ => Self::UnknownValue(i_pv_6_access_type::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for IPv6AccessType {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Ipv6AccessTypeUnspecified => serializer.serialize_i32(0),
            Self::Internal => serializer.serialize_i32(1),
            Self::External => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for IPv6AccessType {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(wkt::internal::EnumVisitor::<IPv6AccessType>::new(
            ".google.container.v1.IPv6AccessType",
        ))
    }
}

/// Options for in-transit encryption.
///
/// # Working with unknown values
///
/// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
/// additional enum variants at any time. Adding new variants is not considered
/// a breaking change. Applications should write their code in anticipation of:
///
/// - New values appearing in future releases of the client library, **and**
/// - New values received dynamically, without application changes.
///
/// Please consult the [Working with enums] section in the user guide for some
/// guidelines.
///
/// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum InTransitEncryptionConfig {
    /// Unspecified, will be inferred as default -
    /// IN_TRANSIT_ENCRYPTION_UNSPECIFIED.
    Unspecified,
    /// In-transit encryption is disabled.
    InTransitEncryptionDisabled,
    /// Data in-transit is encrypted using inter-node transparent encryption.
    InTransitEncryptionInterNodeTransparent,
    /// If set, the enum was initialized with an unknown value.
    ///
    /// Applications can examine the value using [InTransitEncryptionConfig::value] or
    /// [InTransitEncryptionConfig::name].
    UnknownValue(in_transit_encryption_config::UnknownValue),
}

#[doc(hidden)]
pub mod in_transit_encryption_config {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Debug, PartialEq)]
    pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
}

impl InTransitEncryptionConfig {
    /// Gets the enum value.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the string representation of enums.
    pub fn value(&self) -> std::option::Option<i32> {
        match self {
            Self::Unspecified => std::option::Option::Some(0),
            Self::InTransitEncryptionDisabled => std::option::Option::Some(1),
            Self::InTransitEncryptionInterNodeTransparent => std::option::Option::Some(2),
            Self::UnknownValue(u) => u.0.value(),
        }
    }

    /// Gets the enum value as a string.
    ///
    /// Returns `None` if the enum contains an unknown value deserialized from
    /// the integer representation of enums.
    pub fn name(&self) -> std::option::Option<&str> {
        match self {
            Self::Unspecified => {
                std::option::Option::Some("IN_TRANSIT_ENCRYPTION_CONFIG_UNSPECIFIED")
            }
            Self::InTransitEncryptionDisabled => {
                std::option::Option::Some("IN_TRANSIT_ENCRYPTION_DISABLED")
            }
            Self::InTransitEncryptionInterNodeTransparent => {
                std::option::Option::Some("IN_TRANSIT_ENCRYPTION_INTER_NODE_TRANSPARENT")
            }
            Self::UnknownValue(u) => u.0.name(),
        }
    }
}

impl std::default::Default for InTransitEncryptionConfig {
    fn default() -> Self {
        use std::convert::From;
        Self::from(0)
    }
}

impl std::fmt::Display for InTransitEncryptionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
        wkt::internal::display_enum(f, self.name(), self.value())
    }
}

impl std::convert::From<i32> for InTransitEncryptionConfig {
    fn from(value: i32) -> Self {
        match value {
            0 => Self::Unspecified,
            1 => Self::InTransitEncryptionDisabled,
            2 => Self::InTransitEncryptionInterNodeTransparent,
            _ => Self::UnknownValue(in_transit_encryption_config::UnknownValue(
                wkt::internal::UnknownEnumValue::Integer(value),
            )),
        }
    }
}

impl std::convert::From<&str> for InTransitEncryptionConfig {
    fn from(value: &str) -> Self {
        use std::string::ToString;
        match value {
            "IN_TRANSIT_ENCRYPTION_CONFIG_UNSPECIFIED" => Self::Unspecified,
            "IN_TRANSIT_ENCRYPTION_DISABLED" => Self::InTransitEncryptionDisabled,
            "IN_TRANSIT_ENCRYPTION_INTER_NODE_TRANSPARENT" => {
                Self::InTransitEncryptionInterNodeTransparent
            }
            _ => Self::UnknownValue(in_transit_encryption_config::UnknownValue(
                wkt::internal::UnknownEnumValue::String(value.to_string()),
            )),
        }
    }
}

impl serde::ser::Serialize for InTransitEncryptionConfig {
    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::Unspecified => serializer.serialize_i32(0),
            Self::InTransitEncryptionDisabled => serializer.serialize_i32(1),
            Self::InTransitEncryptionInterNodeTransparent => serializer.serialize_i32(2),
            Self::UnknownValue(u) => u.0.serialize(serializer),
        }
    }
}

impl<'de> serde::de::Deserialize<'de> for InTransitEncryptionConfig {
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_any(
            wkt::internal::EnumVisitor::<InTransitEncryptionConfig>::new(
                ".google.container.v1.InTransitEncryptionConfig",
            ),
        )
    }
}