google_cloud_gkemulticloud_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::redundant_explicit_links)]
#![allow(rustdoc::broken_intra_doc_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate google_cloud_type;
extern crate lazy_static;
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;

/// An Anthos cluster running on customer own infrastructure.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedCluster {
    /// The name of this resource.
    ///
    /// Cluster names are formatted as
    /// `projects/<project-number>/locations/<region>/attachedClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    pub name: std::string::String,

    /// Optional. A human readable description of this cluster.
    /// Cannot be longer than 255 UTF-8 encoded bytes.
    pub description: std::string::String,

    /// Required. OpenID Connect (OIDC) configuration for the cluster.
    pub oidc_config: std::option::Option<crate::model::AttachedOidcConfig>,

    /// Required. The platform version for the cluster (e.g. `1.19.0-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAttachedServerConfig][google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig]: crate::client::AttachedClusters::get_attached_server_config
    pub platform_version: std::string::String,

    /// Required. The Kubernetes distribution of the underlying attached cluster.
    ///
    /// Supported values: ["eks", "aks", "generic"].
    pub distribution: std::string::String,

    /// Output only. The region where this cluster runs.
    ///
    /// For EKS clusters, this is a AWS region. For AKS clusters,
    /// this is an Azure region.
    pub cluster_region: std::string::String,

    /// Required. Fleet configuration.
    pub fleet: std::option::Option<crate::model::Fleet>,

    /// Output only. The current state of the cluster.
    pub state: crate::model::attached_cluster::State,

    /// Output only. A globally unique identifier for the cluster.
    pub uid: std::string::String,

    /// Output only. If set, there are currently changes in flight to the cluster.
    pub reconciling: bool,

    /// Output only. The time at which this cluster was registered.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this cluster was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Allows clients to perform consistent read-modify-writes
    /// through optimistic concurrency control.
    ///
    /// Can be sent on update and delete requests to ensure the
    /// client has an up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Output only. The Kubernetes version of the cluster.
    pub kubernetes_version: std::string::String,

    /// Optional. Annotations on the cluster.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Key can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Workload Identity settings.
    pub workload_identity_config: std::option::Option<crate::model::WorkloadIdentityConfig>,

    /// Optional. Logging configuration for this cluster.
    pub logging_config: std::option::Option<crate::model::LoggingConfig>,

    /// Output only. A set of errors found in the cluster.
    pub errors: std::vec::Vec<crate::model::AttachedClusterError>,

    /// Optional. Configuration related to the cluster RBAC settings.
    pub authorization: std::option::Option<crate::model::AttachedClustersAuthorization>,

    /// Optional. Monitoring configuration for this cluster.
    pub monitoring_config: std::option::Option<crate::model::MonitoringConfig>,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AttachedProxyConfig>,

    /// Optional. Binary Authorization configuration for this cluster.
    pub binary_authorization: std::option::Option<crate::model::BinaryAuthorization>,

    /// Optional. Security Posture configuration for this cluster.
    pub security_posture_config: std::option::Option<crate::model::SecurityPostureConfig>,

    /// Optional. Input only. Tag keys and values directly bound to this resource.
    ///
    /// The tag key must be specified in the format
    /// `<tag namespace>/<tag key name>,`
    /// where the tag namespace is the ID of the organization or name of the
    /// project that the tag key is defined in. The short name of a tag key or
    /// value can have a maximum length of 256 characters. The permitted character
    /// set for the short name includes UTF-8 encoded Unicode characters except
    /// single quotation marks (`'`), double quotation marks (`"`), backslashes
    /// (`\`), and forward slashes (`/`).
    ///
    /// See
    /// [Tags](https://cloud.google.com/resource-manager/docs/tags/tags-overview)
    /// for more details on Google Cloud Platform tags.
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Kubernetes configurations for auto-installed components on the
    /// cluster.
    pub system_components_config: std::option::Option<crate::model::SystemComponentsConfig>,

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

impl AttachedCluster {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AttachedCluster::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::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::AttachedCluster::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::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 [oidc_config][crate::model::AttachedCluster::oidc_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::AttachedOidcConfig;
    /// let x = AttachedCluster::new().set_oidc_config(AttachedOidcConfig::default()/* use setters */);
    /// ```
    pub fn set_oidc_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AttachedOidcConfig>,
    {
        self.oidc_config = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

    /// Sets the value of [fleet][crate::model::AttachedCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AttachedCluster::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::AttachedCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AttachedCluster::new().set_or_clear_fleet(Some(Fleet::default()/* use setters */));
    /// let x = AttachedCluster::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 [state][crate::model::AttachedCluster::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::attached_cluster::State;
    /// let x0 = AttachedCluster::new().set_state(State::Provisioning);
    /// let x1 = AttachedCluster::new().set_state(State::Running);
    /// let x2 = AttachedCluster::new().set_state(State::Reconciling);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::attached_cluster::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

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

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

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

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

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

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

    /// Sets the value of [etag][crate::model::AttachedCluster::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::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 [kubernetes_version][crate::model::AttachedCluster::kubernetes_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::new().set_kubernetes_version("example");
    /// ```
    pub fn set_kubernetes_version<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.kubernetes_version = v.into();
        self
    }

    /// Sets the value of [annotations][crate::model::AttachedCluster::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [workload_identity_config][crate::model::AttachedCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AttachedCluster::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::AttachedCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AttachedCluster::new().set_or_clear_workload_identity_config(Some(WorkloadIdentityConfig::default()/* use setters */));
    /// let x = AttachedCluster::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 [logging_config][crate::model::AttachedCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AttachedCluster::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::AttachedCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AttachedCluster::new().set_or_clear_logging_config(Some(LoggingConfig::default()/* use setters */));
    /// let x = AttachedCluster::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 [errors][crate::model::AttachedCluster::errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::AttachedClusterError;
    /// let x = AttachedCluster::new()
    ///     .set_errors([
    ///         AttachedClusterError::default()/* use setters */,
    ///         AttachedClusterError::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_errors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AttachedClusterError>,
    {
        use std::iter::Iterator;
        self.errors = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

    /// Sets the value of [monitoring_config][crate::model::AttachedCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AttachedCluster::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::AttachedCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AttachedCluster::new().set_or_clear_monitoring_config(Some(MonitoringConfig::default()/* use setters */));
    /// let x = AttachedCluster::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 [proxy_config][crate::model::AttachedCluster::proxy_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::AttachedProxyConfig;
    /// let x = AttachedCluster::new().set_proxy_config(AttachedProxyConfig::default()/* use setters */);
    /// ```
    pub fn set_proxy_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AttachedProxyConfig>,
    {
        self.proxy_config = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [binary_authorization][crate::model::AttachedCluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::BinaryAuthorization;
    /// let x = AttachedCluster::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::AttachedCluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::BinaryAuthorization;
    /// let x = AttachedCluster::new().set_or_clear_binary_authorization(Some(BinaryAuthorization::default()/* use setters */));
    /// let x = AttachedCluster::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 [security_posture_config][crate::model::AttachedCluster::security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::SecurityPostureConfig;
    /// let x = AttachedCluster::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::AttachedCluster::security_posture_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// use google_cloud_gkemulticloud_v1::model::SecurityPostureConfig;
    /// let x = AttachedCluster::new().set_or_clear_security_posture_config(Some(SecurityPostureConfig::default()/* use setters */));
    /// let x = AttachedCluster::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 [tags][crate::model::AttachedCluster::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = AttachedCluster::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
    }

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

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

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

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

    /// The lifecycle state 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Not set.
        Unspecified,
        /// The PROVISIONING state indicates the cluster is being registered.
        Provisioning,
        /// The RUNNING state indicates the cluster has been register and is fully
        /// usable.
        Running,
        /// The RECONCILING state indicates that some work is actively being done on
        /// the cluster, such as upgrading software components.
        Reconciling,
        /// The STOPPING state indicates the cluster is being de-registered.
        Stopping,
        /// The ERROR state indicates the cluster is in a broken unrecoverable
        /// state.
        Error,
        /// The DEGRADED state indicates the cluster requires user action to
        /// restore full functionality.
        Degraded,
        /// 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::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("STATE_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 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::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => 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,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => 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::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 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.cloud.gkemulticloud.v1.AttachedCluster.State",
            ))
        }
    }
}

/// Configuration related to the cluster RBAC settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedClustersAuthorization {
    /// Optional. Users that can perform operations as a cluster admin. A managed
    /// ClusterRoleBinding will be created to grant the `cluster-admin` ClusterRole
    /// to the users. Up to ten admin users can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_users: std::vec::Vec<crate::model::AttachedClusterUser>,

    /// Optional. Groups of users that can perform operations as a cluster admin. A
    /// managed ClusterRoleBinding will be created to grant the `cluster-admin`
    /// ClusterRole to the groups. Up to ten admin groups can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_groups: std::vec::Vec<crate::model::AttachedClusterGroup>,

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

impl AttachedClustersAuthorization {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Identities of a user-type subject for Attached clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedClusterUser {
    /// Required. The name of the user, e.g. `my-gcp-id@gmail.com`.
    pub username: std::string::String,

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

impl AttachedClusterUser {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Identities of a group-type subject for Attached clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedClusterGroup {
    /// Required. The name of the group, e.g. `my-group@domain.com`.
    pub group: std::string::String,

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

impl AttachedClusterGroup {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// OIDC discovery information of the target cluster.
///
/// Kubernetes Service Account (KSA) tokens are JWT tokens signed by the cluster
/// API server. This fields indicates how Google Cloud Platform services
/// validate KSA tokens in order to allow system workloads (such as GKE Connect
/// and telemetry agents) to authenticate back to Google Cloud Platform.
///
/// Both clusters with public and private issuer URLs are supported.
/// Clusters with public issuers only need to specify the `issuer_url` field
/// while clusters with private issuers need to provide both
/// `issuer_url` and `oidc_jwks`.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedOidcConfig {
    /// A JSON Web Token (JWT) issuer URI. `issuer` must start with `https://`.
    pub issuer_url: std::string::String,

    /// Optional. OIDC verification keys in JWKS format (RFC 7517).
    /// It contains a list of OIDC verification keys that can be used to verify
    /// OIDC JWTs.
    ///
    /// This field is required for cluster that doesn't have a publicly available
    /// discovery endpoint. When provided, it will be directly used
    /// to verify the OIDC JWT asserted by the IDP.
    pub jwks: ::bytes::Bytes,

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

impl AttachedOidcConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [jwks][crate::model::AttachedOidcConfig::jwks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedOidcConfig;
    /// let x = AttachedOidcConfig::new().set_jwks(bytes::Bytes::from_static(b"example"));
    /// ```
    pub fn set_jwks<T: std::convert::Into<::bytes::Bytes>>(mut self, v: T) -> Self {
        self.jwks = v.into();
        self
    }
}

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

/// AttachedServerConfig provides information about supported
/// Kubernetes versions
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedServerConfig {
    /// The resource name of the config.
    pub name: std::string::String,

    /// List of valid platform versions.
    pub valid_versions: std::vec::Vec<crate::model::AttachedPlatformVersionInfo>,

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

impl AttachedServerConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AttachedServerConfig::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedServerConfig;
    /// let x = AttachedServerConfig::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 [valid_versions][crate::model::AttachedServerConfig::valid_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedServerConfig;
    /// use google_cloud_gkemulticloud_v1::model::AttachedPlatformVersionInfo;
    /// let x = AttachedServerConfig::new()
    ///     .set_valid_versions([
    ///         AttachedPlatformVersionInfo::default()/* use setters */,
    ///         AttachedPlatformVersionInfo::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_valid_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AttachedPlatformVersionInfo>,
    {
        use std::iter::Iterator;
        self.valid_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Information about a supported Attached Clusters platform version.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedPlatformVersionInfo {
    /// Platform version name.
    pub version: std::string::String,

    /// Optional. True if the version is available for attachedcluster creation. If
    /// a version is enabled, it can be used to attach new clusters.
    pub enabled: bool,

    /// Optional. True if this cluster version belongs to a minor version that has
    /// reached its end of life and is no longer in scope to receive security and
    /// bug fixes.
    pub end_of_life: bool,

    /// Optional. The estimated date (in Pacific Time) when this cluster version
    /// will reach its end of life. Or if this version is no longer supported (the
    /// `end_of_life` field is true), this is the actual date (in Pacific time)
    /// when the version reached its end of life.
    pub end_of_life_date: std::option::Option<google_cloud_type::model::Date>,

    /// Optional. The date (in Pacific Time) when the cluster version was released.
    pub release_date: std::option::Option<google_cloud_type::model::Date>,

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

impl AttachedPlatformVersionInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::AttachedPlatformVersionInfo::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedPlatformVersionInfo;
    /// let x = AttachedPlatformVersionInfo::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 [enabled][crate::model::AttachedPlatformVersionInfo::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedPlatformVersionInfo;
    /// let x = AttachedPlatformVersionInfo::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 [end_of_life][crate::model::AttachedPlatformVersionInfo::end_of_life].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedPlatformVersionInfo;
    /// let x = AttachedPlatformVersionInfo::new().set_end_of_life(true);
    /// ```
    pub fn set_end_of_life<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.end_of_life = v.into();
        self
    }

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

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

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

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

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

/// AttachedClusterError describes errors found on attached clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedClusterError {
    /// Human-friendly description of the error.
    pub message: std::string::String,

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

impl AttachedClusterError {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message][crate::model::AttachedClusterError::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AttachedClusterError;
    /// let x = AttachedClusterError::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
    }
}

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

/// Details of a proxy config.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct AttachedProxyConfig {
    /// The Kubernetes Secret resource that contains the HTTP(S) proxy
    /// configuration. The secret must be a JSON encoded proxy configuration
    /// as described in
    /// <https://cloud.google.com/kubernetes-engine/multi-cloud/docs/attached/eks/how-to/use-a-proxy#configure-proxy-support>
    /// for EKS clusters and
    /// <https://cloud.google.com/kubernetes-engine/multi-cloud/docs/attached/aks/how-to/use-a-proxy#configure-proxy-support>
    /// for AKS clusters.
    pub kubernetes_secret: std::option::Option<crate::model::KubernetesSecret>,

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

impl AttachedProxyConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Information about a Kubernetes Secret
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct KubernetesSecret {
    /// Name of the kubernetes secret.
    pub name: std::string::String,

    /// Namespace in which the kubernetes secret is stored.
    pub namespace: std::string::String,

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

impl KubernetesSecret {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::KubernetesSecret::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::KubernetesSecret;
    /// let x = KubernetesSecret::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 [namespace][crate::model::KubernetesSecret::namespace].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::KubernetesSecret;
    /// let x = KubernetesSecret::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
    }
}

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

/// SystemComponentsConfig defines the fields for customizing configurations for
/// auto-installed components.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SystemComponentsConfig {
    /// Sets custom tolerations for pods created by auto-installed components.
    pub tolerations: std::vec::Vec<crate::model::Toleration>,

    /// Sets custom labels for pods created by auto-installed components.
    pub labels: std::vec::Vec<crate::model::Label>,

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

impl SystemComponentsConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Toleration defines the fields for tolerations for pods created by
/// auto-installed components.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Toleration {
    /// Key is the taint key that the toleration applies to.
    pub key: std::string::String,

    /// Value is the taint value that the toleration applies to.
    pub value: std::string::String,

    /// KeyOperator represents a key's relationship to the value e.g. 'Exist'.
    pub key_operator: crate::model::toleration::KeyOperator,

    /// Effect indicates the taint effect to match e.g. 'NoSchedule'
    pub effect: crate::model::toleration::Effect,

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

impl Toleration {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [key][crate::model::Toleration::key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::Toleration;
    /// let x = Toleration::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::Toleration::value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::Toleration;
    /// let x = Toleration::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 [key_operator][crate::model::Toleration::key_operator].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::Toleration;
    /// use google_cloud_gkemulticloud_v1::model::toleration::KeyOperator;
    /// let x0 = Toleration::new().set_key_operator(KeyOperator::Equal);
    /// let x1 = Toleration::new().set_key_operator(KeyOperator::Exists);
    /// ```
    pub fn set_key_operator<T: std::convert::Into<crate::model::toleration::KeyOperator>>(
        mut self,
        v: T,
    ) -> Self {
        self.key_operator = v.into();
        self
    }

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

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

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

    /// KeyOperator represents a key's relationship to the value e.g. 'Equal'.
    ///
    /// # 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum KeyOperator {
        /// Operator is not specified.
        Unspecified,
        /// Operator maps to 'Equal'.
        Equal,
        /// Operator maps to 'Exists'.
        Exists,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [KeyOperator::value] or
        /// [KeyOperator::name].
        UnknownValue(key_operator::UnknownValue),
    }

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

    impl KeyOperator {
        /// 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::Equal => std::option::Option::Some(1),
                Self::Exists => 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("KEY_OPERATOR_UNSPECIFIED"),
                Self::Equal => std::option::Option::Some("KEY_OPERATOR_EQUAL"),
                Self::Exists => std::option::Option::Some("KEY_OPERATOR_EXISTS"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for KeyOperator {
        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 KeyOperator {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Equal,
                2 => Self::Exists,
                _ => Self::UnknownValue(key_operator::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for KeyOperator {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "KEY_OPERATOR_UNSPECIFIED" => Self::Unspecified,
                "KEY_OPERATOR_EQUAL" => Self::Equal,
                "KEY_OPERATOR_EXISTS" => Self::Exists,
                _ => Self::UnknownValue(key_operator::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for KeyOperator {
        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::Equal => serializer.serialize_i32(1),
                Self::Exists => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

    /// Effect indicates the taint effect to match e.g. 'NoSchedule'.
    ///
    /// # 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Effect {
        /// Effect is not specified.
        Unspecified,
        /// Effect maps to 'NoSchedule'.
        NoSchedule,
        /// Effect maps to 'PreferNoSchedule'.
        PreferNoSchedule,
        /// Effect maps to '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("EFFECT_NO_SCHEDULE"),
                Self::PreferNoSchedule => std::option::Option::Some("EFFECT_PREFER_NO_SCHEDULE"),
                Self::NoExecute => std::option::Option::Some("EFFECT_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,
                "EFFECT_NO_SCHEDULE" => Self::NoSchedule,
                "EFFECT_PREFER_NO_SCHEDULE" => Self::PreferNoSchedule,
                "EFFECT_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.cloud.gkemulticloud.v1.Toleration.Effect",
            ))
        }
    }
}

/// Label defines the additional fields for labels for pods created by
/// auto-installed components.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Label {
    /// This is the key of the label.
    pub key: std::string::String,

    /// This is the value of the label.
    pub value: std::string::String,

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

impl Label {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [key][crate::model::Label::key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::Label;
    /// let x = Label::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::Label::value].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::Label;
    /// let x = Label::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
    }
}

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

/// Request message for `AttachedClusters.GenerateAttachedClusterInstallManifest`
/// method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAttachedClusterInstallManifestRequest {
    /// Required. The parent location where this
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// will be created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub parent: std::string::String,

    /// Required. A client provided ID of the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// name formatted as
    /// `projects/<project-id>/locations/<region>/attachedClusters/<cluster-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// When generating an install manifest for importing an existing Membership
    /// resource, the attached_cluster_id field must be the Membership id.
    ///
    /// Membership names are formatted as
    /// `projects/<project-id>/locations/<region>/memberships/<membership-id>`.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub attached_cluster_id: std::string::String,

    /// Required. The platform version for the cluster (e.g. `1.19.0-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAttachedServerConfig][google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig]: crate::client::AttachedClusters::get_attached_server_config
    pub platform_version: std::string::String,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AttachedProxyConfig>,

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

impl GenerateAttachedClusterInstallManifestRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::GenerateAttachedClusterInstallManifestRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAttachedClusterInstallManifestRequest;
    /// let x = GenerateAttachedClusterInstallManifestRequest::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 [attached_cluster_id][crate::model::GenerateAttachedClusterInstallManifestRequest::attached_cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAttachedClusterInstallManifestRequest;
    /// let x = GenerateAttachedClusterInstallManifestRequest::new().set_attached_cluster_id("example");
    /// ```
    pub fn set_attached_cluster_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.attached_cluster_id = v.into();
        self
    }

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

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

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

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

/// Response message for
/// `AttachedClusters.GenerateAttachedClusterInstallManifest` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAttachedClusterInstallManifestResponse {
    /// A set of Kubernetes resources (in YAML format) to be applied
    /// to the cluster to be attached.
    pub manifest: std::string::String,

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

impl GenerateAttachedClusterInstallManifestResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Request message for `AttachedClusters.CreateAttachedCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateAttachedClusterRequest {
    /// Required. The parent location where this
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// will be created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub attached_cluster: std::option::Option<crate::model::AttachedCluster>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// name formatted as
    /// `projects/<project-id>/locations/<region>/attachedClusters/<cluster-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub attached_cluster_id: std::string::String,

    /// If set, only validate the request, but do not actually create the cluster.
    pub validate_only: bool,

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

impl CreateAttachedClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAttachedClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAttachedClusterRequest;
    /// let x = CreateAttachedClusterRequest::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 [attached_cluster][crate::model::CreateAttachedClusterRequest::attached_cluster].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAttachedClusterRequest;
    /// use google_cloud_gkemulticloud_v1::model::AttachedCluster;
    /// let x = CreateAttachedClusterRequest::new().set_attached_cluster(AttachedCluster::default()/* use setters */);
    /// ```
    pub fn set_attached_cluster<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AttachedCluster>,
    {
        self.attached_cluster = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AttachedClusters.ImportAttachedCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ImportAttachedClusterRequest {
    /// Required. The parent location where this
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// will be created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub parent: std::string::String,

    /// If set, only validate the request, but do not actually import the cluster.
    pub validate_only: bool,

    /// Required. The name of the fleet membership resource to import.
    pub fleet_membership: std::string::String,

    /// Required. The platform version for the cluster (e.g. `1.19.0-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAttachedServerConfig][google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedClusters.GetAttachedServerConfig]: crate::client::AttachedClusters::get_attached_server_config
    pub platform_version: std::string::String,

    /// Required. The Kubernetes distribution of the underlying attached cluster.
    ///
    /// Supported values: ["eks", "aks", "generic"].
    pub distribution: std::string::String,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AttachedProxyConfig>,

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

impl ImportAttachedClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ImportAttachedClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ImportAttachedClusterRequest;
    /// let x = ImportAttachedClusterRequest::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 [validate_only][crate::model::ImportAttachedClusterRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ImportAttachedClusterRequest;
    /// let x = ImportAttachedClusterRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

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

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

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

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

/// Request message for `AttachedClusters.UpdateAttachedCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateAttachedClusterRequest {
    /// Required. The
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// to update.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub attached_cluster: std::option::Option<crate::model::AttachedCluster>,

    /// If set, only validate the request, but do not actually update the cluster.
    pub validate_only: bool,

    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field can only include these
    /// fields from
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster]:
    ///
    /// * `annotations`.
    /// * `authorization.admin_groups`.
    /// * `authorization.admin_users`.
    /// * `binary_authorization.evaluation_mode`.
    /// * `description`.
    /// * `logging_config.component_config.enable_components`.
    /// * `monitoring_config.managed_prometheus_config.enabled`.
    /// * `platform_version`.
    /// * `proxy_config.kubernetes_secret.name`.
    /// * `proxy_config.kubernetes_secret.namespace`.
    /// * `security_posture_config.vulnerability_mode`
    /// * `monitoring_config.cloud_monitoring_config.enabled`
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

impl UpdateAttachedClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

/// Request message for `AttachedClusters.GetAttachedCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetAttachedClusterRequest {
    /// Required. The name of the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// to describe.
    ///
    /// `AttachedCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/attachedClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub name: std::string::String,

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

impl GetAttachedClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAttachedClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAttachedClusterRequest;
    /// let x = GetAttachedClusterRequest::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 GetAttachedClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAttachedClusterRequest"
    }
}

/// Request message for `AttachedClusters.ListAttachedClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListAttachedClustersRequest {
    /// Required. The parent location which owns this collection of
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resources.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAttachedClustersResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAttachedClustersResponse.next_page_token]: crate::model::ListAttachedClustersResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [attachedClusters.list][google.cloud.gkemulticloud.v1.AttachedClusters.ListAttachedClusters]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedClusters.ListAttachedClusters]: crate::client::AttachedClusters::list_attached_clusters
    pub page_token: std::string::String,

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

impl ListAttachedClustersRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAttachedClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAttachedClustersRequest;
    /// let x = ListAttachedClustersRequest::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 [page_size][crate::model::ListAttachedClustersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAttachedClustersRequest;
    /// let x = ListAttachedClustersRequest::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::ListAttachedClustersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAttachedClustersRequest;
    /// let x = ListAttachedClustersRequest::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 ListAttachedClustersRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAttachedClustersRequest"
    }
}

/// Response message for `AttachedClusters.ListAttachedClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListAttachedClustersResponse {
    /// A list of [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster]
    /// resources in the specified Google Cloud Platform project and region region.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub attached_clusters: std::vec::Vec<crate::model::AttachedCluster>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAttachedClustersResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAttachedClustersResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAttachedClustersResponse;
    /// let x = ListAttachedClustersResponse::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 ListAttachedClustersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAttachedClustersResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAttachedClustersResponse {
    type PageItem = crate::model::AttachedCluster;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.attached_clusters
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AttachedClusters.DeleteAttachedCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteAttachedClusterRequest {
    /// Required. The resource name the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] to delete.
    ///
    /// `AttachedCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/attachedClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub name: std::string::String,

    /// If set, only validate the request, but do not actually delete the resource.
    pub validate_only: bool,

    /// If set to true, and the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// is not found, the request will succeed but no action will be taken on the
    /// server and a completed [Operation][google.longrunning.Operation] will be
    /// returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// If set to true, the deletion of
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster] resource
    /// will succeed even if errors occur during deleting in cluster resources.
    /// Using this parameter may result in orphaned resources in the cluster.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub ignore_errors: bool,

    /// The current etag of the
    /// [AttachedCluster][google.cloud.gkemulticloud.v1.AttachedCluster].
    ///
    /// Allows clients to perform deletions through optimistic concurrency control.
    ///
    /// If the provided etag does not match the current etag of the cluster,
    /// the request will fail and an ABORTED error will be returned.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedCluster]: crate::model::AttachedCluster
    pub etag: std::string::String,

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

impl DeleteAttachedClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAttachedClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAttachedClusterRequest;
    /// let x = DeleteAttachedClusterRequest::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 [validate_only][crate::model::DeleteAttachedClusterRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAttachedClusterRequest;
    /// let x = DeleteAttachedClusterRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

    /// Sets the value of [etag][crate::model::DeleteAttachedClusterRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAttachedClusterRequest;
    /// let x = DeleteAttachedClusterRequest::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
    }
}

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

/// GetAttachedServerConfigRequest gets the server config for attached
/// clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetAttachedServerConfigRequest {
    /// Required. The name of the
    /// [AttachedServerConfig][google.cloud.gkemulticloud.v1.AttachedServerConfig]
    /// resource to describe.
    ///
    /// `AttachedServerConfig` names are formatted as
    /// `projects/<project-id>/locations/<region>/attachedServerConfig`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AttachedServerConfig]: crate::model::AttachedServerConfig
    pub name: std::string::String,

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

impl GetAttachedServerConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAttachedServerConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAttachedServerConfigRequest;
    /// let x = GetAttachedServerConfigRequest::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 GetAttachedServerConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAttachedServerConfigRequest"
    }
}

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAttachedClusterAgentTokenRequest {
    /// Required.
    pub attached_cluster: std::string::String,

    /// Required.
    pub subject_token: std::string::String,

    /// Required.
    pub subject_token_type: std::string::String,

    /// Required.
    pub version: std::string::String,

    /// Optional.
    pub grant_type: std::string::String,

    /// Optional.
    pub audience: std::string::String,

    /// Optional.
    pub scope: std::string::String,

    /// Optional.
    pub requested_token_type: std::string::String,

    /// Optional.
    pub options: std::string::String,

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

impl GenerateAttachedClusterAgentTokenRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [version][crate::model::GenerateAttachedClusterAgentTokenRequest::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAttachedClusterAgentTokenRequest;
    /// let x = GenerateAttachedClusterAgentTokenRequest::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 [grant_type][crate::model::GenerateAttachedClusterAgentTokenRequest::grant_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAttachedClusterAgentTokenRequest;
    /// let x = GenerateAttachedClusterAgentTokenRequest::new().set_grant_type("example");
    /// ```
    pub fn set_grant_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.grant_type = v.into();
        self
    }

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

    /// Sets the value of [scope][crate::model::GenerateAttachedClusterAgentTokenRequest::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAttachedClusterAgentTokenRequest;
    /// let x = GenerateAttachedClusterAgentTokenRequest::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
    }

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

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GenerateAttachedClusterAgentTokenResponse {
    pub access_token: std::string::String,

    pub expires_in: i32,

    pub token_type: std::string::String,

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

impl GenerateAttachedClusterAgentTokenResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

/// An Anthos cluster running on AWS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsCluster {
    /// The name of this resource.
    ///
    /// Cluster names are formatted as
    /// `projects/<project-number>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    pub name: std::string::String,

    /// Optional. A human readable description of this cluster.
    /// Cannot be longer than 255 UTF-8 encoded bytes.
    pub description: std::string::String,

    /// Required. Cluster-wide networking configuration.
    pub networking: std::option::Option<crate::model::AwsClusterNetworking>,

    /// Required. The AWS region where the cluster runs.
    ///
    /// Each Google Cloud region supports a subset of nearby AWS regions.
    /// You can call
    /// [GetAwsServerConfig][google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig]
    /// to list all supported AWS regions within a given Google Cloud region.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig]: crate::client::AwsClusters::get_aws_server_config
    pub aws_region: std::string::String,

    /// Required. Configuration related to the cluster control plane.
    pub control_plane: std::option::Option<crate::model::AwsControlPlane>,

    /// Required. Configuration related to the cluster RBAC settings.
    pub authorization: std::option::Option<crate::model::AwsAuthorization>,

    /// Output only. The current state of the cluster.
    pub state: crate::model::aws_cluster::State,

    /// Output only. The endpoint of the cluster's API server.
    pub endpoint: std::string::String,

    /// Output only. A globally unique identifier for the cluster.
    pub uid: std::string::String,

    /// Output only. If set, there are currently changes in flight to the cluster.
    pub reconciling: bool,

    /// Output only. The time at which this cluster was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this cluster was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Allows clients to perform consistent read-modify-writes
    /// through optimistic concurrency control.
    ///
    /// Can be sent on update and delete requests to ensure the
    /// client has an up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Optional. Annotations on the cluster.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Key can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Workload Identity settings.
    pub workload_identity_config: std::option::Option<crate::model::WorkloadIdentityConfig>,

    /// Output only. PEM encoded x509 certificate of the cluster root of trust.
    pub cluster_ca_certificate: std::string::String,

    /// Required. Fleet configuration.
    pub fleet: std::option::Option<crate::model::Fleet>,

    /// Optional. Logging configuration for this cluster.
    pub logging_config: std::option::Option<crate::model::LoggingConfig>,

    /// Output only. A set of errors found in the cluster.
    pub errors: std::vec::Vec<crate::model::AwsClusterError>,

    /// Optional. Monitoring configuration for this cluster.
    pub monitoring_config: std::option::Option<crate::model::MonitoringConfig>,

    /// Optional. Binary Authorization configuration for this cluster.
    pub binary_authorization: std::option::Option<crate::model::BinaryAuthorization>,

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

impl AwsCluster {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AwsCluster::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::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::AwsCluster::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::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 [networking][crate::model::AwsCluster::networking].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::AwsClusterNetworking;
    /// let x = AwsCluster::new().set_networking(AwsClusterNetworking::default()/* use setters */);
    /// ```
    pub fn set_networking<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AwsClusterNetworking>,
    {
        self.networking = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

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

    /// Sets the value of [state][crate::model::AwsCluster::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::aws_cluster::State;
    /// let x0 = AwsCluster::new().set_state(State::Provisioning);
    /// let x1 = AwsCluster::new().set_state(State::Running);
    /// let x2 = AwsCluster::new().set_state(State::Reconciling);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::aws_cluster::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [endpoint][crate::model::AwsCluster::endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::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 [uid][crate::model::AwsCluster::uid].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::new().set_uid("example");
    /// ```
    pub fn set_uid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uid = v.into();
        self
    }

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

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

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

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

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

    /// Sets the value of [etag][crate::model::AwsCluster::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::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 [annotations][crate::model::AwsCluster::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [workload_identity_config][crate::model::AwsCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AwsCluster::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::AwsCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AwsCluster::new().set_or_clear_workload_identity_config(Some(WorkloadIdentityConfig::default()/* use setters */));
    /// let x = AwsCluster::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 [cluster_ca_certificate][crate::model::AwsCluster::cluster_ca_certificate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = AwsCluster::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 [fleet][crate::model::AwsCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AwsCluster::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::AwsCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AwsCluster::new().set_or_clear_fleet(Some(Fleet::default()/* use setters */));
    /// let x = AwsCluster::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 [logging_config][crate::model::AwsCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AwsCluster::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::AwsCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AwsCluster::new().set_or_clear_logging_config(Some(LoggingConfig::default()/* use setters */));
    /// let x = AwsCluster::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 [errors][crate::model::AwsCluster::errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::AwsClusterError;
    /// let x = AwsCluster::new()
    ///     .set_errors([
    ///         AwsClusterError::default()/* use setters */,
    ///         AwsClusterError::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_errors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AwsClusterError>,
    {
        use std::iter::Iterator;
        self.errors = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [monitoring_config][crate::model::AwsCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AwsCluster::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::AwsCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AwsCluster::new().set_or_clear_monitoring_config(Some(MonitoringConfig::default()/* use setters */));
    /// let x = AwsCluster::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 [binary_authorization][crate::model::AwsCluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::BinaryAuthorization;
    /// let x = AwsCluster::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::AwsCluster::binary_authorization].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// use google_cloud_gkemulticloud_v1::model::BinaryAuthorization;
    /// let x = AwsCluster::new().set_or_clear_binary_authorization(Some(BinaryAuthorization::default()/* use setters */));
    /// let x = AwsCluster::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
    }
}

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

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

    /// The lifecycle state 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// 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 control plane replicas.
        Reconciling,
        /// The STOPPING state indicates the cluster is being deleted.
        Stopping,
        /// The ERROR state indicates the cluster is in a broken unrecoverable
        /// state.
        Error,
        /// The DEGRADED state indicates the cluster requires user action to
        /// restore full functionality.
        Degraded,
        /// 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::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("STATE_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 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::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => 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,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => 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::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 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.cloud.gkemulticloud.v1.AwsCluster.State",
            ))
        }
    }
}

/// ControlPlane defines common parameters between control plane nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsControlPlane {
    /// Required. The Kubernetes version to run on control plane replicas
    /// (e.g. `1.19.10-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAwsServerConfig][google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig]: crate::client::AwsClusters::get_aws_server_config
    pub version: std::string::String,

    /// Optional. The AWS instance type.
    ///
    /// When unspecified, it uses a default based on the cluster's version.
    pub instance_type: std::string::String,

    /// Optional. SSH configuration for how to access the underlying control plane
    /// machines.
    pub ssh_config: std::option::Option<crate::model::AwsSshConfig>,

    /// Required. The list of subnets where control plane replicas will run.
    /// A replica will be provisioned on each subnet and up to three values
    /// can be provided.
    /// Each subnet must be in a different AWS Availability Zone (AZ).
    pub subnet_ids: std::vec::Vec<std::string::String>,

    /// Optional. The IDs of additional security groups to add to control plane
    /// replicas. The Anthos Multi-Cloud API will automatically create and manage
    /// security groups with the minimum rules needed for a functioning cluster.
    pub security_group_ids: std::vec::Vec<std::string::String>,

    /// Required. The name or ARN of the AWS IAM instance profile to assign to each
    /// control plane replica.
    pub iam_instance_profile: std::string::String,

    /// Optional. Configuration related to the root volume provisioned for each
    /// control plane replica.
    ///
    /// Volumes will be provisioned in the availability zone associated
    /// with the corresponding subnet.
    ///
    /// When unspecified, it defaults to 32 GiB with the GP2 volume type.
    pub root_volume: std::option::Option<crate::model::AwsVolumeTemplate>,

    /// Optional. Configuration related to the main volume provisioned for each
    /// control plane replica.
    /// The main volume is in charge of storing all of the cluster's etcd state.
    ///
    /// Volumes will be provisioned in the availability zone associated
    /// with the corresponding subnet.
    ///
    /// When unspecified, it defaults to 8 GiB with the GP2 volume type.
    pub main_volume: std::option::Option<crate::model::AwsVolumeTemplate>,

    /// Required. The ARN of the AWS KMS key used to encrypt cluster secrets.
    pub database_encryption: std::option::Option<crate::model::AwsDatabaseEncryption>,

    /// Optional. A set of AWS resource tags to propagate to all underlying managed
    /// AWS resources.
    ///
    /// Specify at most 50 pairs containing alphanumerics, spaces, and symbols
    /// (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to
    /// 255 Unicode characters.
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. Authentication configuration for management of AWS resources.
    pub aws_services_authentication: std::option::Option<crate::model::AwsServicesAuthentication>,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AwsProxyConfig>,

    /// Required. Config encryption for user data.
    pub config_encryption: std::option::Option<crate::model::AwsConfigEncryption>,

    /// Optional. The placement to use on control plane instances.
    /// When unspecified, the VPC's default tenancy will be used.
    pub instance_placement: std::option::Option<crate::model::AwsInstancePlacement>,

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

impl AwsControlPlane {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::AwsControlPlane::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsControlPlane;
    /// let x = AwsControlPlane::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_type][crate::model::AwsControlPlane::instance_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsControlPlane;
    /// let x = AwsControlPlane::new().set_instance_type("example");
    /// ```
    pub fn set_instance_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.instance_type = v.into();
        self
    }

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

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

    /// Sets the value of [subnet_ids][crate::model::AwsControlPlane::subnet_ids].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsControlPlane;
    /// let x = AwsControlPlane::new().set_subnet_ids(["a", "b", "c"]);
    /// ```
    pub fn set_subnet_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.subnet_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [security_group_ids][crate::model::AwsControlPlane::security_group_ids].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsControlPlane;
    /// let x = AwsControlPlane::new().set_security_group_ids(["a", "b", "c"]);
    /// ```
    pub fn set_security_group_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.security_group_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

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

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

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

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

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

    /// Sets the value of [tags][crate::model::AwsControlPlane::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsControlPlane;
    /// let x = AwsControlPlane::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
    }

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

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

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

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

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

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

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

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

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

/// Authentication configuration for the management of AWS resources.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsServicesAuthentication {
    /// Required. The Amazon Resource Name (ARN) of the role that the Anthos
    /// Multi-Cloud API will assume when managing AWS resources on your account.
    pub role_arn: std::string::String,

    /// Optional. An identifier for the assumed role session.
    ///
    /// When unspecified, it defaults to `multicloud-service-agent`.
    pub role_session_name: std::string::String,

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

impl AwsServicesAuthentication {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Configuration related to the cluster RBAC settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsAuthorization {
    /// Optional. Users that can perform operations as a cluster admin. A managed
    /// ClusterRoleBinding will be created to grant the `cluster-admin` ClusterRole
    /// to the users. Up to ten admin users can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_users: std::vec::Vec<crate::model::AwsClusterUser>,

    /// Optional. Groups of users that can perform operations as a cluster admin. A
    /// managed ClusterRoleBinding will be created to grant the `cluster-admin`
    /// ClusterRole to the groups. Up to ten admin groups can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_groups: std::vec::Vec<crate::model::AwsClusterGroup>,

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

impl AwsAuthorization {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Identities of a user-type subject for AWS clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsClusterUser {
    /// Required. The name of the user, e.g. `my-gcp-id@gmail.com`.
    pub username: std::string::String,

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

impl AwsClusterUser {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Identities of a group-type subject for AWS clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsClusterGroup {
    /// Required. The name of the group, e.g. `my-group@domain.com`.
    pub group: std::string::String,

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

impl AwsClusterGroup {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Configuration related to application-layer secrets encryption.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsDatabaseEncryption {
    /// Required. The ARN of the AWS KMS key used to encrypt cluster secrets.
    pub kms_key_arn: std::string::String,

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

impl AwsDatabaseEncryption {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Configuration template for AWS EBS volumes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsVolumeTemplate {
    /// Optional. The size of the volume, in GiBs.
    ///
    /// When unspecified, a default value is provided. See the specific reference
    /// in the parent resource.
    pub size_gib: i32,

    /// Optional. Type of the EBS volume.
    ///
    /// When unspecified, it defaults to GP2 volume.
    pub volume_type: crate::model::aws_volume_template::VolumeType,

    /// Optional. The number of I/O operations per second (IOPS) to provision for
    /// GP3 volume.
    pub iops: i32,

    /// Optional. The throughput that the volume supports, in MiB/s. Only valid if
    /// volume_type is GP3.
    ///
    /// If the volume_type is GP3 and this is not specified, it defaults to 125.
    pub throughput: i32,

    /// Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK)
    /// used to encrypt AWS EBS volumes.
    ///
    /// If not specified, the default Amazon managed key associated to
    /// the AWS region where this cluster runs will be used.
    pub kms_key_arn: std::string::String,

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

impl AwsVolumeTemplate {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [volume_type][crate::model::AwsVolumeTemplate::volume_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsVolumeTemplate;
    /// use google_cloud_gkemulticloud_v1::model::aws_volume_template::VolumeType;
    /// let x0 = AwsVolumeTemplate::new().set_volume_type(VolumeType::Gp2);
    /// let x1 = AwsVolumeTemplate::new().set_volume_type(VolumeType::Gp3);
    /// ```
    pub fn set_volume_type<T: std::convert::Into<crate::model::aws_volume_template::VolumeType>>(
        mut self,
        v: T,
    ) -> Self {
        self.volume_type = v.into();
        self
    }

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

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

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

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

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

    /// Types of supported EBS volumes. We currently only support GP2 or GP3
    /// volumes.
    /// See <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html>
    /// for more information.
    ///
    /// # 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum VolumeType {
        /// Not set.
        Unspecified,
        /// GP2 (General Purpose SSD volume type).
        Gp2,
        /// GP3 (General Purpose SSD volume type).
        Gp3,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [VolumeType::value] or
        /// [VolumeType::name].
        UnknownValue(volume_type::UnknownValue),
    }

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

    impl VolumeType {
        /// 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::Gp2 => std::option::Option::Some(1),
                Self::Gp3 => 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("VOLUME_TYPE_UNSPECIFIED"),
                Self::Gp2 => std::option::Option::Some("GP2"),
                Self::Gp3 => std::option::Option::Some("GP3"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for VolumeType {
        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 VolumeType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Gp2,
                2 => Self::Gp3,
                _ => Self::UnknownValue(volume_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for VolumeType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "VOLUME_TYPE_UNSPECIFIED" => Self::Unspecified,
                "GP2" => Self::Gp2,
                "GP3" => Self::Gp3,
                _ => Self::UnknownValue(volume_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for VolumeType {
        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::Gp2 => serializer.serialize_i32(1),
                Self::Gp3 => serializer.serialize_i32(2),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// ClusterNetworking defines cluster-wide networking configuration.
///
/// Anthos clusters on AWS run on a single VPC. This includes control
/// plane replicas and node pool nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsClusterNetworking {
    /// Required. The VPC associated with the cluster. All component clusters
    /// (i.e. control plane and node pools) run on a single VPC.
    ///
    /// This field cannot be changed after creation.
    pub vpc_id: std::string::String,

    /// Required. All pods in the cluster are assigned an IPv4 address from these
    /// ranges. Only a single range is supported. This field cannot be changed
    /// after creation.
    pub pod_address_cidr_blocks: std::vec::Vec<std::string::String>,

    /// Required. All services in the cluster are assigned an IPv4 address from
    /// these ranges. Only a single range is supported. This field cannot be
    /// changed after creation.
    pub service_address_cidr_blocks: std::vec::Vec<std::string::String>,

    /// Optional. Disable the per node pool subnet security group rules on the
    /// control plane security group. When set to true, you must also provide one
    /// or more security groups that ensure node pools are able to send requests to
    /// the control plane on TCP/443 and TCP/8132. Failure to do so may result in
    /// unavailable node pools.
    pub per_node_pool_sg_rules_disabled: bool,

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

impl AwsClusterNetworking {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [pod_address_cidr_blocks][crate::model::AwsClusterNetworking::pod_address_cidr_blocks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsClusterNetworking;
    /// let x = AwsClusterNetworking::new().set_pod_address_cidr_blocks(["a", "b", "c"]);
    /// ```
    pub fn set_pod_address_cidr_blocks<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_address_cidr_blocks = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service_address_cidr_blocks][crate::model::AwsClusterNetworking::service_address_cidr_blocks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsClusterNetworking;
    /// let x = AwsClusterNetworking::new().set_service_address_cidr_blocks(["a", "b", "c"]);
    /// ```
    pub fn set_service_address_cidr_blocks<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_address_cidr_blocks = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

/// An Anthos node pool running on AWS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsNodePool {
    /// The name of this resource.
    ///
    /// Node pool names are formatted as
    /// `projects/<project-number>/locations/<region>/awsClusters/<cluster-id>/awsNodePools/<node-pool-id>`.
    ///
    /// For more details on Google Cloud resource names,
    /// see [Resource Names](https://cloud.google.com/apis/design/resource_names)
    pub name: std::string::String,

    /// Required. The Kubernetes version to run on this node pool (e.g.
    /// `1.19.10-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAwsServerConfig][google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AwsClusters.GetAwsServerConfig]: crate::client::AwsClusters::get_aws_server_config
    pub version: std::string::String,

    /// Required. The configuration of the node pool.
    pub config: std::option::Option<crate::model::AwsNodeConfig>,

    /// Required. Autoscaler configuration for this node pool.
    pub autoscaling: std::option::Option<crate::model::AwsNodePoolAutoscaling>,

    /// Required. The subnet where the node pool node run.
    pub subnet_id: std::string::String,

    /// Output only. The lifecycle state of the node pool.
    pub state: crate::model::aws_node_pool::State,

    /// Output only. A globally unique identifier for the node pool.
    pub uid: std::string::String,

    /// Output only. If set, there are currently changes in flight to the node
    /// pool.
    pub reconciling: bool,

    /// Output only. The time at which this node pool was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this node pool was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Allows clients to perform consistent read-modify-writes
    /// through optimistic concurrency control.
    ///
    /// Can be sent on update and delete requests to ensure the
    /// client has an up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Optional. Annotations on the node pool.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Key can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. 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>,

    /// Output only. A set of errors found in the node pool.
    pub errors: std::vec::Vec<crate::model::AwsNodePoolError>,

    /// Optional. The Management configuration for this node pool.
    pub management: std::option::Option<crate::model::AwsNodeManagement>,

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

    /// Optional. Update settings control the speed and disruption of the update.
    pub update_settings: std::option::Option<crate::model::UpdateSettings>,

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

impl AwsNodePool {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AwsNodePool::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// let x = AwsNodePool::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::AwsNodePool::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// let x = AwsNodePool::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 [config][crate::model::AwsNodePool::config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// let x = AwsNodePool::new().set_config(AwsNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AwsNodeConfig>,
    {
        self.config = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

    /// Sets the value of [state][crate::model::AwsNodePool::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::aws_node_pool::State;
    /// let x0 = AwsNodePool::new().set_state(State::Provisioning);
    /// let x1 = AwsNodePool::new().set_state(State::Running);
    /// let x2 = AwsNodePool::new().set_state(State::Reconciling);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::aws_node_pool::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

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

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

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

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

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

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

    /// Sets the value of [etag][crate::model::AwsNodePool::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// let x = AwsNodePool::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 [annotations][crate::model::AwsNodePool::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// let x = AwsNodePool::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [max_pods_constraint][crate::model::AwsNodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::MaxPodsConstraint;
    /// let x = AwsNodePool::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::AwsNodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::MaxPodsConstraint;
    /// let x = AwsNodePool::new().set_or_clear_max_pods_constraint(Some(MaxPodsConstraint::default()/* use setters */));
    /// let x = AwsNodePool::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 [errors][crate::model::AwsNodePool::errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::AwsNodePoolError;
    /// let x = AwsNodePool::new()
    ///     .set_errors([
    ///         AwsNodePoolError::default()/* use setters */,
    ///         AwsNodePoolError::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_errors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AwsNodePoolError>,
    {
        use std::iter::Iterator;
        self.errors = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

    /// Sets the value of [kubelet_config][crate::model::AwsNodePool::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = AwsNodePool::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::AwsNodePool::kubelet_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = AwsNodePool::new().set_or_clear_kubelet_config(Some(NodeKubeletConfig::default()/* use setters */));
    /// let x = AwsNodePool::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 [update_settings][crate::model::AwsNodePool::update_settings].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// use google_cloud_gkemulticloud_v1::model::UpdateSettings;
    /// let x = AwsNodePool::new().set_update_settings(UpdateSettings::default()/* use setters */);
    /// ```
    pub fn set_update_settings<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::UpdateSettings>,
    {
        self.update_settings = std::option::Option::Some(v.into());
        self
    }

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

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

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

    /// The lifecycle state of 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// 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 RECONCILING state indicates that the node pool is being reconciled.
        Reconciling,
        /// The STOPPING state indicates the node pool is being deleted.
        Stopping,
        /// The ERROR state indicates the node pool is in a broken unrecoverable
        /// state.
        Error,
        /// The DEGRADED state indicates the node pool requires user action to
        /// restore full functionality.
        Degraded,
        /// 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::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("STATE_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 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::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => 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,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => 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::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 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.cloud.gkemulticloud.v1.AwsNodePool.State",
            ))
        }
    }
}

/// UpdateSettings control the level of parallelism and the level of
/// disruption caused during the update of a node pool.
///
/// These settings are applicable when the node pool update requires replacing
/// the existing node pool nodes with the updated ones.
///
/// UpdateSettings are optional. When UpdateSettings are not specified during the
/// node pool creation, a default is chosen based on the parent cluster's
/// version. For clusters with minor version 1.27 and later, a default
/// surge_settings configuration with max_surge = 1 and max_unavailable = 0 is
/// used. For clusters with older versions, node pool updates use the traditional
/// rolling update mechanism of updating one node at a time in a
/// "terminate before create" fashion and update_settings is not applicable.
///
/// Set the surge_settings parameter to use the Surge Update mechanism for
/// the rolling update of node pool nodes.
///
/// 1. max_surge controls the number of additional nodes that can be created
///    beyond the current size of the node pool temporarily for the time of the
///    update to increase the number of available nodes.
/// 1. max_unavailable controls the number of nodes that can be simultaneously
///    unavailable during the update.
/// 1. (max_surge + max_unavailable) determines the level of parallelism (i.e.,
///    the number of nodes being updated at the same time).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct UpdateSettings {
    /// Optional. Settings for surge update.
    pub surge_settings: std::option::Option<crate::model::SurgeSettings>,

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

impl UpdateSettings {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// SurgeSettings contains the parameters for Surge update.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct SurgeSettings {
    /// Optional. The maximum number of nodes that can be created beyond the
    /// current size of the node pool during the update process.
    pub max_surge: i32,

    /// Optional. The maximum number of nodes that can be simultaneously
    /// unavailable during the update process. A node is considered unavailable if
    /// its status is not Ready.
    pub max_unavailable: i32,

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

impl SurgeSettings {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [max_surge][crate::model::SurgeSettings::max_surge].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::SurgeSettings;
    /// let x = SurgeSettings::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::SurgeSettings::max_unavailable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::SurgeSettings;
    /// let x = SurgeSettings::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
    }
}

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

/// AwsNodeManagement defines the set of node management features turned on for
/// an AWS node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsNodeManagement {
    /// Optional. Whether or not the nodes will be automatically repaired. When set
    /// to true, the nodes in this node pool will be monitored and if they fail
    /// health checks consistently over a period of time, an automatic repair
    /// action will be triggered to replace them with new nodes.
    pub auto_repair: bool,

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

impl AwsNodeManagement {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auto_repair][crate::model::AwsNodeManagement::auto_repair].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeManagement;
    /// let x = AwsNodeManagement::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
    }
}

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

/// Parameters that describe the nodes in a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsNodeConfig {
    /// Optional. The EC2 instance type when creating on-Demand instances.
    ///
    /// If unspecified during node pool creation, a default will be chosen based on
    /// the node pool version, and assigned to this field.
    pub instance_type: std::string::String,

    /// Optional. Template for the root volume provisioned for node pool nodes.
    /// Volumes will be provisioned in the availability zone assigned
    /// to the node pool subnet.
    ///
    /// When unspecified, it defaults to 32 GiB with the GP2 volume type.
    pub root_volume: std::option::Option<crate::model::AwsVolumeTemplate>,

    /// Optional. The initial taints assigned to nodes of this node pool.
    pub taints: std::vec::Vec<crate::model::NodeTaint>,

    /// Optional. The initial labels assigned to nodes of this node pool. An object
    /// containing a list of "key": value pairs. Example: { "name": "wrench",
    /// "mass": "1.3kg", "count": "3" }.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Key/value metadata to assign to each underlying AWS resource.
    /// Specify at most 50 pairs containing alphanumerics, spaces, and symbols
    /// (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to
    /// 255 Unicode characters.
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. The name or ARN of the AWS IAM instance profile to assign to
    /// nodes in the pool.
    pub iam_instance_profile: std::string::String,

    /// Optional. The OS image type to use on node pool instances.
    /// Can be unspecified, or have a value of `ubuntu`.
    ///
    /// When unspecified, it defaults to `ubuntu`.
    pub image_type: std::string::String,

    /// Optional. The SSH configuration.
    pub ssh_config: std::option::Option<crate::model::AwsSshConfig>,

    /// Optional. The IDs of additional security groups to add to nodes in this
    /// pool. The manager will automatically create security groups with minimum
    /// rules needed for a functioning cluster.
    pub security_group_ids: std::vec::Vec<std::string::String>,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AwsProxyConfig>,

    /// Required. Config encryption for user data.
    pub config_encryption: std::option::Option<crate::model::AwsConfigEncryption>,

    /// Optional. Placement related info for this node.
    /// When unspecified, the VPC's default tenancy will be used.
    pub instance_placement: std::option::Option<crate::model::AwsInstancePlacement>,

    /// Optional. Configuration related to CloudWatch metrics collection on the
    /// Auto Scaling group of the node pool.
    ///
    /// When unspecified, metrics collection is disabled.
    pub autoscaling_metrics_collection:
        std::option::Option<crate::model::AwsAutoscalingGroupMetricsCollection>,

    /// Optional. Configuration for provisioning EC2 Spot instances
    ///
    /// When specified, the node pool will provision Spot instances from the set
    /// of spot_config.instance_types.
    /// This field is mutually exclusive with `instance_type`.
    pub spot_config: std::option::Option<crate::model::SpotConfig>,

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

impl AwsNodeConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [taints][crate::model::AwsNodeConfig::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// use google_cloud_gkemulticloud_v1::model::NodeTaint;
    /// let x = AwsNodeConfig::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 [labels][crate::model::AwsNodeConfig::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// let x = AwsNodeConfig::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 [tags][crate::model::AwsNodeConfig::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// let x = AwsNodeConfig::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
    }

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

    /// Sets the value of [image_type][crate::model::AwsNodeConfig::image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// let x = AwsNodeConfig::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 [ssh_config][crate::model::AwsNodeConfig::ssh_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// use google_cloud_gkemulticloud_v1::model::AwsSshConfig;
    /// let x = AwsNodeConfig::new().set_ssh_config(AwsSshConfig::default()/* use setters */);
    /// ```
    pub fn set_ssh_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AwsSshConfig>,
    {
        self.ssh_config = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [security_group_ids][crate::model::AwsNodeConfig::security_group_ids].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodeConfig;
    /// let x = AwsNodeConfig::new().set_security_group_ids(["a", "b", "c"]);
    /// ```
    pub fn set_security_group_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.security_group_ids = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

/// AwsNodePoolAutoscaling 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]
#[deprecated]
pub struct AwsNodePoolAutoscaling {
    /// Required. Minimum number of nodes in the node pool. Must be greater than or
    /// equal to 1 and less than or equal to max_node_count.
    pub min_node_count: i32,

    /// Required. Maximum number of nodes in the node pool. Must be greater than or
    /// equal to min_node_count and less than or equal to 50.
    pub max_node_count: i32,

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

impl AwsNodePoolAutoscaling {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [min_node_count][crate::model::AwsNodePoolAutoscaling::min_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePoolAutoscaling;
    /// let x = AwsNodePoolAutoscaling::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::AwsNodePoolAutoscaling::max_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePoolAutoscaling;
    /// let x = AwsNodePoolAutoscaling::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
    }
}

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

/// AwsOpenIdConfig is an OIDC discovery document for the cluster.
/// See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsOpenIdConfig {
    /// 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 AwsOpenIdConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [issuer][crate::model::AwsOpenIdConfig::issuer].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::jwks_uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::response_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::subject_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::id_token_signing_alg_values_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::claims_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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::AwsOpenIdConfig::grant_types].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsOpenIdConfig;
    /// let x = AwsOpenIdConfig::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 AwsOpenIdConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.AwsOpenIdConfig"
    }
}

/// AwsJsonWebKeys is a valid JSON Web Key Set as specififed in RFC 7517.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsJsonWebKeys {
    /// 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 AwsJsonWebKeys {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [keys][crate::model::AwsJsonWebKeys::keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsJsonWebKeys;
    /// use google_cloud_gkemulticloud_v1::model::Jwk;
    /// let x = AwsJsonWebKeys::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 AwsJsonWebKeys {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.AwsJsonWebKeys"
    }
}

/// AwsServerConfig is the configuration of GKE cluster on AWS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsServerConfig {
    /// The resource name of the config.
    pub name: std::string::String,

    /// List of all released Kubernetes versions, including ones which are end of
    /// life and can no longer be used.  Filter by the `enabled`
    /// property to limit to currently available versions.
    /// Valid versions supported for both create and update operations
    pub valid_versions: std::vec::Vec<crate::model::AwsK8sVersionInfo>,

    /// The list of supported AWS regions.
    pub supported_aws_regions: std::vec::Vec<std::string::String>,

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

impl AwsServerConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AwsServerConfig::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsServerConfig;
    /// let x = AwsServerConfig::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 [valid_versions][crate::model::AwsServerConfig::valid_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsServerConfig;
    /// use google_cloud_gkemulticloud_v1::model::AwsK8sVersionInfo;
    /// let x = AwsServerConfig::new()
    ///     .set_valid_versions([
    ///         AwsK8sVersionInfo::default()/* use setters */,
    ///         AwsK8sVersionInfo::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_valid_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AwsK8sVersionInfo>,
    {
        use std::iter::Iterator;
        self.valid_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [supported_aws_regions][crate::model::AwsServerConfig::supported_aws_regions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsServerConfig;
    /// let x = AwsServerConfig::new().set_supported_aws_regions(["a", "b", "c"]);
    /// ```
    pub fn set_supported_aws_regions<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.supported_aws_regions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Kubernetes version information of GKE cluster on AWS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsK8sVersionInfo {
    /// Kubernetes version name.
    pub version: std::string::String,

    /// Optional. True if the version is available for cluster creation. If a
    /// version is enabled for creation, it can be used to create new clusters.
    /// Otherwise, cluster creation will fail. However, cluster upgrade operations
    /// may succeed, even if the version is not enabled.
    pub enabled: bool,

    /// Optional. True if this cluster version belongs to a minor version that has
    /// reached its end of life and is no longer in scope to receive security and
    /// bug fixes.
    pub end_of_life: bool,

    /// Optional. The estimated date (in Pacific Time) when this cluster version
    /// will reach its end of life. Or if this version is no longer supported (the
    /// `end_of_life` field is true), this is the actual date (in Pacific time)
    /// when the version reached its end of life.
    pub end_of_life_date: std::option::Option<google_cloud_type::model::Date>,

    /// Optional. The date (in Pacific Time) when the cluster version was released.
    pub release_date: std::option::Option<google_cloud_type::model::Date>,

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

impl AwsK8sVersionInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::AwsK8sVersionInfo::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsK8sVersionInfo;
    /// let x = AwsK8sVersionInfo::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 [enabled][crate::model::AwsK8sVersionInfo::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsK8sVersionInfo;
    /// let x = AwsK8sVersionInfo::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 [end_of_life][crate::model::AwsK8sVersionInfo::end_of_life].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsK8sVersionInfo;
    /// let x = AwsK8sVersionInfo::new().set_end_of_life(true);
    /// ```
    pub fn set_end_of_life<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.end_of_life = v.into();
        self
    }

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

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

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

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

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

/// SSH configuration for AWS resources.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsSshConfig {
    /// Required. The name of the EC2 key pair used to login into cluster machines.
    pub ec2_key_pair: std::string::String,

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

impl AwsSshConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Details of a proxy config stored in AWS Secret Manager.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsProxyConfig {
    /// The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy
    /// configuration.
    ///
    /// The secret must be a JSON encoded proxy configuration
    /// as described in
    /// <https://cloud.google.com/kubernetes-engine/multi-cloud/docs/aws/how-to/use-a-proxy#create_a_proxy_configuration_file>
    pub secret_arn: std::string::String,

    /// The version string of the AWS Secret Manager secret that contains the
    /// HTTP(S) proxy configuration.
    pub secret_version: std::string::String,

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

impl AwsProxyConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Config encryption for user data.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsConfigEncryption {
    /// Required. The ARN of the AWS KMS key used to encrypt user data.
    pub kms_key_arn: std::string::String,

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

impl AwsConfigEncryption {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Details of placement information for an instance.
/// Limitations for using the `host` tenancy:
///
/// * T3 instances that use the unlimited CPU credit option don't support host
///   tenancy.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsInstancePlacement {
    /// Required. The tenancy for instance.
    pub tenancy: crate::model::aws_instance_placement::Tenancy,

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

impl AwsInstancePlacement {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [tenancy][crate::model::AwsInstancePlacement::tenancy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsInstancePlacement;
    /// use google_cloud_gkemulticloud_v1::model::aws_instance_placement::Tenancy;
    /// let x0 = AwsInstancePlacement::new().set_tenancy(Tenancy::Default);
    /// let x1 = AwsInstancePlacement::new().set_tenancy(Tenancy::Dedicated);
    /// let x2 = AwsInstancePlacement::new().set_tenancy(Tenancy::Host);
    /// ```
    pub fn set_tenancy<T: std::convert::Into<crate::model::aws_instance_placement::Tenancy>>(
        mut self,
        v: T,
    ) -> Self {
        self.tenancy = v.into();
        self
    }
}

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

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

    /// Tenancy defines how EC2 instances are distributed across physical hardware.
    ///
    /// # 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Tenancy {
        /// Not set.
        Unspecified,
        /// Use default VPC tenancy.
        Default,
        /// Run a dedicated instance.
        Dedicated,
        /// Launch this instance to a dedicated host.
        Host,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Tenancy::value] or
        /// [Tenancy::name].
        UnknownValue(tenancy::UnknownValue),
    }

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

    impl Tenancy {
        /// 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::Dedicated => std::option::Option::Some(2),
                Self::Host => 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("TENANCY_UNSPECIFIED"),
                Self::Default => std::option::Option::Some("DEFAULT"),
                Self::Dedicated => std::option::Option::Some("DEDICATED"),
                Self::Host => std::option::Option::Some("HOST"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

    impl std::fmt::Display for Tenancy {
        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 Tenancy {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Default,
                2 => Self::Dedicated,
                3 => Self::Host,
                _ => Self::UnknownValue(tenancy::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for Tenancy {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TENANCY_UNSPECIFIED" => Self::Unspecified,
                "DEFAULT" => Self::Default,
                "DEDICATED" => Self::Dedicated,
                "HOST" => Self::Host,
                _ => Self::UnknownValue(tenancy::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for Tenancy {
        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::Dedicated => serializer.serialize_i32(2),
                Self::Host => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Configuration related to CloudWatch metrics collection in an AWS
/// Auto Scaling group.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsAutoscalingGroupMetricsCollection {
    /// Required. The frequency at which EC2 Auto Scaling sends aggregated data to
    /// AWS CloudWatch. The only valid value is "1Minute".
    pub granularity: std::string::String,

    /// Optional. The metrics to enable. For a list of valid metrics, see
    /// <https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html>.
    /// If you specify Granularity and don't specify any metrics, all metrics are
    /// enabled.
    pub metrics: std::vec::Vec<std::string::String>,

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

impl AwsAutoscalingGroupMetricsCollection {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [metrics][crate::model::AwsAutoscalingGroupMetricsCollection::metrics].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsAutoscalingGroupMetricsCollection;
    /// let x = AwsAutoscalingGroupMetricsCollection::new().set_metrics(["a", "b", "c"]);
    /// ```
    pub fn set_metrics<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.metrics = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// SpotConfig has configuration info for Spot node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct SpotConfig {
    /// Required. A list of instance types for creating spot node pool.
    pub instance_types: std::vec::Vec<std::string::String>,

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

impl SpotConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [instance_types][crate::model::SpotConfig::instance_types].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::SpotConfig;
    /// let x = SpotConfig::new().set_instance_types(["a", "b", "c"]);
    /// ```
    pub fn set_instance_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.instance_types = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// AwsClusterError describes errors found on AWS clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsClusterError {
    /// Human-friendly description of the error.
    pub message: std::string::String,

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

impl AwsClusterError {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message][crate::model::AwsClusterError::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsClusterError;
    /// let x = AwsClusterError::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
    }
}

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

/// AwsNodePoolError describes errors found on AWS node pools.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AwsNodePoolError {
    /// Human-friendly description of the error.
    pub message: std::string::String,

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

impl AwsNodePoolError {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message][crate::model::AwsNodePoolError::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AwsNodePoolError;
    /// let x = AwsNodePoolError::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
    }
}

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

/// Request message for `AwsClusters.CreateAwsCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CreateAwsClusterRequest {
    /// Required. The parent location where this
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource will be
    /// created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub aws_cluster: std::option::Option<crate::model::AwsCluster>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource name
    /// formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub aws_cluster_id: std::string::String,

    /// If set, only validate the request, but do not actually create the cluster.
    pub validate_only: bool,

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

impl CreateAwsClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAwsClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAwsClusterRequest;
    /// let x = CreateAwsClusterRequest::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 [aws_cluster][crate::model::CreateAwsClusterRequest::aws_cluster].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAwsClusterRequest;
    /// use google_cloud_gkemulticloud_v1::model::AwsCluster;
    /// let x = CreateAwsClusterRequest::new().set_aws_cluster(AwsCluster::default()/* use setters */);
    /// ```
    pub fn set_aws_cluster<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AwsCluster>,
    {
        self.aws_cluster = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AwsClusters.UpdateAwsCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct UpdateAwsClusterRequest {
    /// Required. The [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster]
    /// resource to update.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub aws_cluster: std::option::Option<crate::model::AwsCluster>,

    /// If set, only validate the request, but do not actually update the cluster.
    pub validate_only: bool,

    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field can only include these
    /// fields from [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster]:
    ///
    /// * `description`.
    /// * `annotations`.
    /// * `control_plane.version`.
    /// * `authorization.admin_users`.
    /// * `authorization.admin_groups`.
    /// * `binary_authorization.evaluation_mode`.
    /// * `control_plane.aws_services_authentication.role_arn`.
    /// * `control_plane.aws_services_authentication.role_session_name`.
    /// * `control_plane.config_encryption.kms_key_arn`.
    /// * `control_plane.instance_type`.
    /// * `control_plane.security_group_ids`.
    /// * `control_plane.proxy_config`.
    /// * `control_plane.proxy_config.secret_arn`.
    /// * `control_plane.proxy_config.secret_version`.
    /// * `control_plane.root_volume.size_gib`.
    /// * `control_plane.root_volume.volume_type`.
    /// * `control_plane.root_volume.iops`.
    /// * `control_plane.root_volume.throughput`.
    /// * `control_plane.root_volume.kms_key_arn`.
    /// * `control_plane.ssh_config`.
    /// * `control_plane.ssh_config.ec2_key_pair`.
    /// * `control_plane.instance_placement.tenancy`.
    /// * `control_plane.iam_instance_profile`.
    /// * `logging_config.component_config.enable_components`.
    /// * `control_plane.tags`.
    /// * `monitoring_config.managed_prometheus_config.enabled`.
    /// * `networking.per_node_pool_sg_rules_disabled`.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

impl UpdateAwsClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

/// Request message for `AwsClusters.GetAwsCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAwsClusterRequest {
    /// Required. The name of the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource to
    /// describe.
    ///
    /// `AwsCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub name: std::string::String,

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

impl GetAwsClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAwsClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAwsClusterRequest;
    /// let x = GetAwsClusterRequest::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 GetAwsClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAwsClusterRequest"
    }
}

/// Request message for `AwsClusters.ListAwsClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAwsClustersRequest {
    /// Required. The parent location which owns this collection of
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resources.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAwsClustersResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAwsClustersResponse.next_page_token]: crate::model::ListAwsClustersResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [awsClusters.list][google.cloud.gkemulticloud.v1.AwsClusters.ListAwsClusters]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsClusters.ListAwsClusters]: crate::client::AwsClusters::list_aws_clusters
    pub page_token: std::string::String,

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

impl ListAwsClustersRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAwsClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsClustersRequest;
    /// let x = ListAwsClustersRequest::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 [page_size][crate::model::ListAwsClustersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsClustersRequest;
    /// let x = ListAwsClustersRequest::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::ListAwsClustersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsClustersRequest;
    /// let x = ListAwsClustersRequest::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 ListAwsClustersRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAwsClustersRequest"
    }
}

/// Response message for `AwsClusters.ListAwsClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAwsClustersResponse {
    /// A list of [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resources
    /// in the specified Google Cloud Platform project and region region.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub aws_clusters: std::vec::Vec<crate::model::AwsCluster>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAwsClustersResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAwsClustersResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsClustersResponse;
    /// let x = ListAwsClustersResponse::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 ListAwsClustersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAwsClustersResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAwsClustersResponse {
    type PageItem = crate::model::AwsCluster;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.aws_clusters
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AwsClusters.DeleteAwsCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DeleteAwsClusterRequest {
    /// Required. The resource name the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] to delete.
    ///
    /// `AwsCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub name: std::string::String,

    /// If set, only validate the request, but do not actually delete the resource.
    pub validate_only: bool,

    /// If set to true, and the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource is not
    /// found, the request will succeed but no action will be taken on the server
    /// and a completed [Operation][google.longrunning.Operation] will be returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// Optional. If set to true, the deletion of
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource will
    /// succeed even if errors occur during deleting in cluster resources. Using
    /// this parameter may result in orphaned resources in the cluster.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub ignore_errors: bool,

    /// The current etag of the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster].
    ///
    /// Allows clients to perform deletions through optimistic concurrency control.
    ///
    /// If the provided etag does not match the current etag of the cluster,
    /// the request will fail and an ABORTED error will be returned.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub etag: std::string::String,

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

impl DeleteAwsClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAwsClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsClusterRequest;
    /// let x = DeleteAwsClusterRequest::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 [validate_only][crate::model::DeleteAwsClusterRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsClusterRequest;
    /// let x = DeleteAwsClusterRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

    /// Sets the value of [etag][crate::model::DeleteAwsClusterRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsClusterRequest;
    /// let x = DeleteAwsClusterRequest::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
    }
}

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

/// Response message for `AwsClusters.CreateAwsNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CreateAwsNodePoolRequest {
    /// Required. The [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster]
    /// resource where this node pool will be created.
    ///
    /// `AwsCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub aws_node_pool: std::option::Option<crate::model::AwsNodePool>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resource name
    /// formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>/awsNodePools/<node-pool-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub aws_node_pool_id: std::string::String,

    /// If set, only validate the request, but do not actually create the node
    /// pool.
    pub validate_only: bool,

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

impl CreateAwsNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAwsNodePoolRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAwsNodePoolRequest;
    /// let x = CreateAwsNodePoolRequest::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 [aws_node_pool][crate::model::CreateAwsNodePoolRequest::aws_node_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAwsNodePoolRequest;
    /// use google_cloud_gkemulticloud_v1::model::AwsNodePool;
    /// let x = CreateAwsNodePoolRequest::new().set_aws_node_pool(AwsNodePool::default()/* use setters */);
    /// ```
    pub fn set_aws_node_pool<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AwsNodePool>,
    {
        self.aws_node_pool = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AwsClusters.UpdateAwsNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct UpdateAwsNodePoolRequest {
    /// Required. The [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool]
    /// resource to update.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub aws_node_pool: std::option::Option<crate::model::AwsNodePool>,

    /// If set, only validate the request, but don't actually update the node pool.
    pub validate_only: bool,

    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field can only include these
    /// fields from [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool]:
    ///
    /// * `annotations`.
    /// * `version`.
    /// * `autoscaling.min_node_count`.
    /// * `autoscaling.max_node_count`.
    /// * `config.config_encryption.kms_key_arn`.
    /// * `config.security_group_ids`.
    /// * `config.root_volume.iops`.
    /// * `config.root_volume.throughput`.
    /// * `config.root_volume.kms_key_arn`.
    /// * `config.root_volume.volume_type`.
    /// * `config.root_volume.size_gib`.
    /// * `config.proxy_config`.
    /// * `config.proxy_config.secret_arn`.
    /// * `config.proxy_config.secret_version`.
    /// * `config.ssh_config`.
    /// * `config.ssh_config.ec2_key_pair`.
    /// * `config.instance_placement.tenancy`.
    /// * `config.iam_instance_profile`.
    /// * `config.labels`.
    /// * `config.tags`.
    /// * `config.autoscaling_metrics_collection`.
    /// * `config.autoscaling_metrics_collection.granularity`.
    /// * `config.autoscaling_metrics_collection.metrics`.
    /// * `config.instance_type`.
    /// * `management.auto_repair`.
    /// * `management`.
    /// * `update_settings`.
    /// * `update_settings.surge_settings`.
    /// * `update_settings.surge_settings.max_surge`.
    /// * `update_settings.surge_settings.max_unavailable`.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

impl UpdateAwsNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

/// Request message for `AwsClusters.RollbackAwsNodePoolUpdate` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct RollbackAwsNodePoolUpdateRequest {
    /// Required. The name of the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resource to
    /// rollback.
    ///
    /// `AwsNodePool` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>/awsNodePools/<node-pool-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub name: std::string::String,

    /// Optional. Option for rollback to ignore the PodDisruptionBudget when
    /// draining the node pool nodes. Default value is false.
    pub respect_pdb: bool,

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

impl RollbackAwsNodePoolUpdateRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::RollbackAwsNodePoolUpdateRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::RollbackAwsNodePoolUpdateRequest;
    /// let x = RollbackAwsNodePoolUpdateRequest::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::RollbackAwsNodePoolUpdateRequest::respect_pdb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::RollbackAwsNodePoolUpdateRequest;
    /// let x = RollbackAwsNodePoolUpdateRequest::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 RollbackAwsNodePoolUpdateRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.RollbackAwsNodePoolUpdateRequest"
    }
}

/// Request message for `AwsClusters.GetAwsNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAwsNodePoolRequest {
    /// Required. The name of the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resource to
    /// describe.
    ///
    /// `AwsNodePool` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>/awsNodePools/<node-pool-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub name: std::string::String,

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

impl GetAwsNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAwsNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAwsNodePoolRequest;
    /// let x = GetAwsNodePoolRequest::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 GetAwsNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAwsNodePoolRequest"
    }
}

/// Request message for `AwsClusters.ListAwsNodePools` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAwsNodePoolsRequest {
    /// Required. The parent `AwsCluster` which owns this collection of
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resources.
    ///
    /// `AwsCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAwsNodePoolsResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAwsNodePoolsResponse.next_page_token]: crate::model::ListAwsNodePoolsResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [awsNodePools.list][google.cloud.gkemulticloud.v1.AwsClusters.ListAwsNodePools]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsClusters.ListAwsNodePools]: crate::client::AwsClusters::list_aws_node_pools
    pub page_token: std::string::String,

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

impl ListAwsNodePoolsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAwsNodePoolsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsNodePoolsRequest;
    /// let x = ListAwsNodePoolsRequest::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 [page_size][crate::model::ListAwsNodePoolsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsNodePoolsRequest;
    /// let x = ListAwsNodePoolsRequest::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::ListAwsNodePoolsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsNodePoolsRequest;
    /// let x = ListAwsNodePoolsRequest::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 ListAwsNodePoolsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAwsNodePoolsRequest"
    }
}

/// Response message for `AwsClusters.ListAwsNodePools` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAwsNodePoolsResponse {
    /// A list of [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool]
    /// resources in the specified `AwsCluster`.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub aws_node_pools: std::vec::Vec<crate::model::AwsNodePool>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAwsNodePoolsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAwsNodePoolsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAwsNodePoolsResponse;
    /// let x = ListAwsNodePoolsResponse::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 ListAwsNodePoolsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAwsNodePoolsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAwsNodePoolsResponse {
    type PageItem = crate::model::AwsNodePool;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.aws_node_pools
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AwsClusters.DeleteAwsNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DeleteAwsNodePoolRequest {
    /// Required. The resource name the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] to delete.
    ///
    /// `AwsNodePool` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>/awsNodePools/<node-pool-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub name: std::string::String,

    /// If set, only validate the request, but do not actually delete the node
    /// pool.
    pub validate_only: bool,

    /// If set to true, and the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resource is not
    /// found, the request will succeed but no action will be taken on the server
    /// and a completed [Operation][google.longrunning.Operation] will be returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// Optional. If set to true, the deletion of
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool] resource will
    /// succeed even if errors occur during deleting in node pool resources. Using
    /// this parameter may result in orphaned resources in the node pool.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub ignore_errors: bool,

    /// The current ETag of the
    /// [AwsNodePool][google.cloud.gkemulticloud.v1.AwsNodePool].
    ///
    /// Allows clients to perform deletions through optimistic concurrency control.
    ///
    /// If the provided ETag does not match the current etag of the node pool,
    /// the request will fail and an ABORTED error will be returned.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsNodePool]: crate::model::AwsNodePool
    pub etag: std::string::String,

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

impl DeleteAwsNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAwsNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsNodePoolRequest;
    /// let x = DeleteAwsNodePoolRequest::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 [validate_only][crate::model::DeleteAwsNodePoolRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsNodePoolRequest;
    /// let x = DeleteAwsNodePoolRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

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

    /// Sets the value of [etag][crate::model::DeleteAwsNodePoolRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAwsNodePoolRequest;
    /// let x = DeleteAwsNodePoolRequest::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
    }
}

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

/// GetAwsOpenIdConfigRequest gets the OIDC discovery document for the
/// cluster. See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAwsOpenIdConfigRequest {
    /// Required. The AwsCluster, which owns the OIDC discovery document.
    /// Format:
    /// projects/{project}/locations/{location}/awsClusters/{cluster}
    pub aws_cluster: std::string::String,

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

impl GetAwsOpenIdConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// GetAwsJsonWebKeysRequest 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]
#[deprecated]
pub struct GetAwsJsonWebKeysRequest {
    /// Required. The AwsCluster, which owns the JsonWebKeys.
    /// Format:
    /// projects/{project}/locations/{location}/awsClusters/{cluster}
    pub aws_cluster: std::string::String,

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

impl GetAwsJsonWebKeysRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// GetAwsServerConfigRequest gets the server config of GKE cluster on AWS.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAwsServerConfigRequest {
    /// Required. The name of the
    /// [AwsServerConfig][google.cloud.gkemulticloud.v1.AwsServerConfig] resource
    /// to describe.
    ///
    /// `AwsServerConfig` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsServerConfig`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsServerConfig]: crate::model::AwsServerConfig
    pub name: std::string::String,

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

impl GetAwsServerConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAwsServerConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAwsServerConfigRequest;
    /// let x = GetAwsServerConfigRequest::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 GetAwsServerConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAwsServerConfigRequest"
    }
}

/// Request message for `AwsClusters.GenerateAwsAccessToken` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAwsAccessTokenRequest {
    /// Required. The name of the
    /// [AwsCluster][google.cloud.gkemulticloud.v1.AwsCluster] resource to
    /// authenticate to.
    ///
    /// `AwsCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/awsClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AwsCluster]: crate::model::AwsCluster
    pub aws_cluster: std::string::String,

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

impl GenerateAwsAccessTokenRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Response message for `AwsClusters.GenerateAwsAccessToken` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAwsAccessTokenResponse {
    /// Output only. Access token to authenticate to k8s api-server.
    pub access_token: std::string::String,

    /// Output only. Timestamp at which the token will expire.
    pub expiration_time: std::option::Option<wkt::Timestamp>,

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

impl GenerateAwsAccessTokenResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAwsClusterAgentTokenRequest {
    /// Required.
    pub aws_cluster: std::string::String,

    /// Required.
    pub subject_token: std::string::String,

    /// Required.
    pub subject_token_type: std::string::String,

    /// Required.
    pub version: std::string::String,

    /// Optional.
    pub node_pool_id: std::string::String,

    /// Optional.
    pub grant_type: std::string::String,

    /// Optional.
    pub audience: std::string::String,

    /// Optional.
    pub scope: std::string::String,

    /// Optional.
    pub requested_token_type: std::string::String,

    /// Optional.
    pub options: std::string::String,

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

impl GenerateAwsClusterAgentTokenRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [version][crate::model::GenerateAwsClusterAgentTokenRequest::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAwsClusterAgentTokenRequest;
    /// let x = GenerateAwsClusterAgentTokenRequest::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 [node_pool_id][crate::model::GenerateAwsClusterAgentTokenRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAwsClusterAgentTokenRequest;
    /// let x = GenerateAwsClusterAgentTokenRequest::new().set_node_pool_id("example");
    /// ```
    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 [grant_type][crate::model::GenerateAwsClusterAgentTokenRequest::grant_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAwsClusterAgentTokenRequest;
    /// let x = GenerateAwsClusterAgentTokenRequest::new().set_grant_type("example");
    /// ```
    pub fn set_grant_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.grant_type = v.into();
        self
    }

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

    /// Sets the value of [scope][crate::model::GenerateAwsClusterAgentTokenRequest::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAwsClusterAgentTokenRequest;
    /// let x = GenerateAwsClusterAgentTokenRequest::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
    }

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

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAwsClusterAgentTokenResponse {
    pub access_token: std::string::String,

    pub expires_in: i32,

    pub token_type: std::string::String,

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

impl GenerateAwsClusterAgentTokenResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

/// An Anthos cluster running on Azure.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureCluster {
    /// The name of this resource.
    ///
    /// Cluster names are formatted as
    /// `projects/<project-number>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    pub name: std::string::String,

    /// Optional. A human readable description of this cluster.
    /// Cannot be longer than 255 UTF-8 encoded bytes.
    pub description: std::string::String,

    /// Required. The Azure region where the cluster runs.
    ///
    /// Each Google Cloud region supports a subset of nearby Azure regions.
    /// You can call
    /// [GetAzureServerConfig][google.cloud.gkemulticloud.v1.AzureClusters.GetAzureServerConfig]
    /// to list all supported Azure regions within a given Google Cloud region.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClusters.GetAzureServerConfig]: crate::client::AzureClusters::get_azure_server_config
    pub azure_region: std::string::String,

    /// Required. The ARM ID of the resource group where the cluster resources are
    /// deployed. For example:
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>`
    pub resource_group_id: std::string::String,

    /// Optional. Name of the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] that contains
    /// authentication configuration for how the Anthos Multi-Cloud API connects to
    /// Azure APIs.
    ///
    /// Either azure_client or azure_services_authentication should be provided.
    ///
    /// The `AzureClient` resource must reside on the same Google Cloud Platform
    /// project and region as the `AzureCluster`.
    ///
    /// `AzureClient` names are formatted as
    /// `projects/<project-number>/locations/<region>/azureClients/<client-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub azure_client: std::string::String,

    /// Required. Cluster-wide networking configuration.
    pub networking: std::option::Option<crate::model::AzureClusterNetworking>,

    /// Required. Configuration related to the cluster control plane.
    pub control_plane: std::option::Option<crate::model::AzureControlPlane>,

    /// Required. Configuration related to the cluster RBAC settings.
    pub authorization: std::option::Option<crate::model::AzureAuthorization>,

    /// Optional. Authentication configuration for management of Azure resources.
    ///
    /// Either azure_client or azure_services_authentication should be provided.
    pub azure_services_authentication:
        std::option::Option<crate::model::AzureServicesAuthentication>,

    /// Output only. The current state of the cluster.
    pub state: crate::model::azure_cluster::State,

    /// Output only. The endpoint of the cluster's API server.
    pub endpoint: std::string::String,

    /// Output only. A globally unique identifier for the cluster.
    pub uid: std::string::String,

    /// Output only. If set, there are currently changes in flight to the cluster.
    pub reconciling: bool,

    /// Output only. The time at which this cluster was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this cluster was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Allows clients to perform consistent read-modify-writes
    /// through optimistic concurrency control.
    ///
    /// Can be sent on update and delete requests to ensure the
    /// client has an up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Optional. Annotations on the cluster.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Keys can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Workload Identity settings.
    pub workload_identity_config: std::option::Option<crate::model::WorkloadIdentityConfig>,

    /// Output only. PEM encoded x509 certificate of the cluster root of trust.
    pub cluster_ca_certificate: std::string::String,

    /// Required. Fleet configuration.
    pub fleet: std::option::Option<crate::model::Fleet>,

    /// Output only. Managed Azure resources for this cluster.
    pub managed_resources: std::option::Option<crate::model::AzureClusterResources>,

    /// Optional. Logging configuration for this cluster.
    pub logging_config: std::option::Option<crate::model::LoggingConfig>,

    /// Output only. A set of errors found in the cluster.
    pub errors: std::vec::Vec<crate::model::AzureClusterError>,

    /// Optional. Monitoring configuration for this cluster.
    pub monitoring_config: std::option::Option<crate::model::MonitoringConfig>,

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

impl AzureCluster {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AzureCluster::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::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::AzureCluster::description].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::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 [azure_region][crate::model::AzureCluster::azure_region].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::new().set_azure_region("example");
    /// ```
    pub fn set_azure_region<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.azure_region = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [state][crate::model::AzureCluster::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::azure_cluster::State;
    /// let x0 = AzureCluster::new().set_state(State::Provisioning);
    /// let x1 = AzureCluster::new().set_state(State::Running);
    /// let x2 = AzureCluster::new().set_state(State::Reconciling);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::azure_cluster::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [endpoint][crate::model::AzureCluster::endpoint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::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 [uid][crate::model::AzureCluster::uid].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::new().set_uid("example");
    /// ```
    pub fn set_uid<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.uid = v.into();
        self
    }

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

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

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

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

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

    /// Sets the value of [etag][crate::model::AzureCluster::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::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 [annotations][crate::model::AzureCluster::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [workload_identity_config][crate::model::AzureCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AzureCluster::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::AzureCluster::workload_identity_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::WorkloadIdentityConfig;
    /// let x = AzureCluster::new().set_or_clear_workload_identity_config(Some(WorkloadIdentityConfig::default()/* use setters */));
    /// let x = AzureCluster::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 [cluster_ca_certificate][crate::model::AzureCluster::cluster_ca_certificate].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = AzureCluster::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 [fleet][crate::model::AzureCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AzureCluster::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::AzureCluster::fleet].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::Fleet;
    /// let x = AzureCluster::new().set_or_clear_fleet(Some(Fleet::default()/* use setters */));
    /// let x = AzureCluster::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 [managed_resources][crate::model::AzureCluster::managed_resources].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::AzureClusterResources;
    /// let x = AzureCluster::new().set_managed_resources(AzureClusterResources::default()/* use setters */);
    /// ```
    pub fn set_managed_resources<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureClusterResources>,
    {
        self.managed_resources = std::option::Option::Some(v.into());
        self
    }

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

    /// Sets the value of [logging_config][crate::model::AzureCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AzureCluster::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::AzureCluster::logging_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::LoggingConfig;
    /// let x = AzureCluster::new().set_or_clear_logging_config(Some(LoggingConfig::default()/* use setters */));
    /// let x = AzureCluster::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 [errors][crate::model::AzureCluster::errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::AzureClusterError;
    /// let x = AzureCluster::new()
    ///     .set_errors([
    ///         AzureClusterError::default()/* use setters */,
    ///         AzureClusterError::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_errors<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AzureClusterError>,
    {
        use std::iter::Iterator;
        self.errors = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [monitoring_config][crate::model::AzureCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AzureCluster::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::AzureCluster::monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// let x = AzureCluster::new().set_or_clear_monitoring_config(Some(MonitoringConfig::default()/* use setters */));
    /// let x = AzureCluster::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
    }
}

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

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

    /// The lifecycle state 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// 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 control plane replicas.
        Reconciling,
        /// The STOPPING state indicates the cluster is being deleted.
        Stopping,
        /// The ERROR state indicates the cluster is in a broken unrecoverable
        /// state.
        Error,
        /// The DEGRADED state indicates the cluster requires user action to
        /// restore full functionality.
        Degraded,
        /// 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::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("STATE_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 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::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => 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,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => 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::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 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.cloud.gkemulticloud.v1.AzureCluster.State",
            ))
        }
    }
}

/// ClusterNetworking contains cluster-wide networking configuration.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClusterNetworking {
    /// Required. The Azure Resource Manager (ARM) ID of the VNet associated with
    /// your cluster.
    ///
    /// All components in the cluster (i.e. control plane and node pools) run on a
    /// single VNet.
    ///
    /// Example:
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-id>/providers/Microsoft.Network/virtualNetworks/<vnet-id>`
    ///
    /// This field cannot be changed after creation.
    pub virtual_network_id: std::string::String,

    /// Required. The IP address range of the pods in this cluster, in CIDR
    /// notation (e.g. `10.96.0.0/14`).
    ///
    /// All pods in the cluster get assigned a unique IPv4 address from these
    /// ranges. Only a single range is supported.
    ///
    /// This field cannot be changed after creation.
    pub pod_address_cidr_blocks: std::vec::Vec<std::string::String>,

    /// Required. The IP address range for services in this cluster, in CIDR
    /// notation (e.g. `10.96.0.0/14`).
    ///
    /// All services in the cluster get assigned a unique IPv4 address from these
    /// ranges. Only a single range is supported.
    ///
    /// This field cannot be changed after creating a cluster.
    pub service_address_cidr_blocks: std::vec::Vec<std::string::String>,

    /// Optional. The ARM ID of the subnet where Kubernetes private service type
    /// load balancers are deployed. When unspecified, it defaults to
    /// AzureControlPlane.subnet_id.
    ///
    /// Example:
    /// "/subscriptions/d00494d6-6f3c-4280-bbb2-899e163d1d30/resourceGroups/anthos_cluster_gkeust4/providers/Microsoft.Network/virtualNetworks/gke-vnet-gkeust4/subnets/subnetid456"
    pub service_load_balancer_subnet_id: std::string::String,

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

impl AzureClusterNetworking {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [pod_address_cidr_blocks][crate::model::AzureClusterNetworking::pod_address_cidr_blocks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClusterNetworking;
    /// let x = AzureClusterNetworking::new().set_pod_address_cidr_blocks(["a", "b", "c"]);
    /// ```
    pub fn set_pod_address_cidr_blocks<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_address_cidr_blocks = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [service_address_cidr_blocks][crate::model::AzureClusterNetworking::service_address_cidr_blocks].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClusterNetworking;
    /// let x = AzureClusterNetworking::new().set_service_address_cidr_blocks(["a", "b", "c"]);
    /// ```
    pub fn set_service_address_cidr_blocks<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_address_cidr_blocks = v.into_iter().map(|i| i.into()).collect();
        self
    }

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

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

/// AzureControlPlane represents the control plane configurations.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureControlPlane {
    /// Required. The Kubernetes version to run on control plane replicas
    /// (e.g. `1.19.10-gke.1000`).
    ///
    /// You can list all supported versions on a given Google Cloud region by
    /// calling
    /// [GetAzureServerConfig][google.cloud.gkemulticloud.v1.AzureClusters.GetAzureServerConfig].
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClusters.GetAzureServerConfig]: crate::client::AzureClusters::get_azure_server_config
    pub version: std::string::String,

    /// Optional. The ARM ID of the default subnet for the control plane. The
    /// control plane VMs are deployed in this subnet, unless
    /// `AzureControlPlane.replica_placements` is specified. This subnet will also
    /// be used as default for `AzureControlPlane.endpoint_subnet_id` if
    /// `AzureControlPlane.endpoint_subnet_id` is not specified. Similarly it will
    /// be used as default for
    /// `AzureClusterNetworking.service_load_balancer_subnet_id`.
    ///
    /// Example:
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-id>/providers/Microsoft.Network/virtualNetworks/<vnet-id>/subnets/default`.
    pub subnet_id: std::string::String,

    /// Optional. The Azure VM size name. Example: `Standard_DS2_v2`.
    ///
    /// For available VM sizes, see
    /// <https://docs.microsoft.com/en-us/azure/virtual-machines/vm-naming-conventions>.
    ///
    /// When unspecified, it defaults to `Standard_DS2_v2`.
    pub vm_size: std::string::String,

    /// Required. SSH configuration for how to access the underlying control plane
    /// machines.
    pub ssh_config: std::option::Option<crate::model::AzureSshConfig>,

    /// Optional. Configuration related to the root volume provisioned for each
    /// control plane replica.
    ///
    /// When unspecified, it defaults to 32-GiB Azure Disk.
    pub root_volume: std::option::Option<crate::model::AzureDiskTemplate>,

    /// Optional. Configuration related to the main volume provisioned for each
    /// control plane replica.
    /// The main volume is in charge of storing all of the cluster's etcd state.
    ///
    /// When unspecified, it defaults to a 8-GiB Azure Disk.
    pub main_volume: std::option::Option<crate::model::AzureDiskTemplate>,

    /// Optional. Configuration related to application-layer secrets encryption.
    pub database_encryption: std::option::Option<crate::model::AzureDatabaseEncryption>,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AzureProxyConfig>,

    /// Optional. Configuration related to vm config encryption.
    pub config_encryption: std::option::Option<crate::model::AzureConfigEncryption>,

    /// Optional. A set of tags to apply to all underlying control plane Azure
    /// resources.
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Configuration for where to place the control plane replicas.
    ///
    /// Up to three replica placement instances can be specified. If
    /// replica_placements is set, the replica placement instances will be applied
    /// to the three control plane replicas as evenly as possible.
    pub replica_placements: std::vec::Vec<crate::model::ReplicaPlacement>,

    /// Optional. The ARM ID of the subnet where the control plane load balancer is
    /// deployed. When unspecified, it defaults to AzureControlPlane.subnet_id.
    ///
    /// Example:
    /// "/subscriptions/d00494d6-6f3c-4280-bbb2-899e163d1d30/resourceGroups/anthos_cluster_gkeust4/providers/Microsoft.Network/virtualNetworks/gke-vnet-gkeust4/subnets/subnetid123"
    pub endpoint_subnet_id: std::string::String,

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

impl AzureControlPlane {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::AzureControlPlane::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureControlPlane;
    /// let x = AzureControlPlane::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 [subnet_id][crate::model::AzureControlPlane::subnet_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureControlPlane;
    /// let x = AzureControlPlane::new().set_subnet_id("example");
    /// ```
    pub fn set_subnet_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.subnet_id = v.into();
        self
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Sets the value of [tags][crate::model::AzureControlPlane::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureControlPlane;
    /// let x = AzureControlPlane::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
    }

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

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

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

/// Configuration for the placement of a control plane replica.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ReplicaPlacement {
    /// Required. For a given replica, the ARM ID of the subnet where the control
    /// plane VM is deployed. Make sure it's a subnet under the virtual network in
    /// the cluster configuration.
    pub subnet_id: std::string::String,

    /// Required. For a given replica, the Azure availability zone where to
    /// provision the control plane VM and the ETCD disk.
    pub azure_availability_zone: std::string::String,

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

impl ReplicaPlacement {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Details of a proxy config stored in Azure Key Vault.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureProxyConfig {
    /// The ARM ID the of the resource group containing proxy keyvault.
    ///
    /// Resource group ids are formatted as
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>`.
    pub resource_group_id: std::string::String,

    /// The URL the of the proxy setting secret with its version.
    ///
    /// The secret must be a JSON encoded proxy configuration
    /// as described in
    /// <https://cloud.google.com/kubernetes-engine/multi-cloud/docs/azure/how-to/use-a-proxy#create_a_proxy_configuration_file>
    ///
    /// Secret ids are formatted as
    /// `https://<key-vault-name>.vault.azure.net/secrets/<secret-name>/<secret-version>`.
    pub secret_id: std::string::String,

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

impl AzureProxyConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Configuration related to application-layer secrets encryption.
///
/// Anthos clusters on Azure encrypts your Kubernetes data at rest
/// in etcd using Azure Key Vault.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureDatabaseEncryption {
    /// Required. The ARM ID of the Azure Key Vault key to encrypt / decrypt data.
    ///
    /// For example:
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-id>/providers/Microsoft.KeyVault/vaults/<key-vault-id>/keys/<key-name>`
    /// Encryption will always take the latest version of the key and hence
    /// specific version is not supported.
    pub key_id: std::string::String,

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

impl AzureDatabaseEncryption {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Configuration related to config data encryption.
///
/// Azure VM bootstrap secret is envelope encrypted with the provided key vault
/// key.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureConfigEncryption {
    /// Required. The ARM ID of the Azure Key Vault key to encrypt / decrypt config
    /// data.
    ///
    /// For example:
    /// `/subscriptions/<subscription-id>/resourceGroups/<resource-group-id>/providers/Microsoft.KeyVault/vaults/<key-vault-id>/keys/<key-name>`
    pub key_id: std::string::String,

    /// Optional. RSA key of the Azure Key Vault public key to use for encrypting
    /// the data.
    ///
    /// This key must be formatted as a PEM-encoded SubjectPublicKeyInfo (RFC 5280)
    /// in ASN.1 DER form. The string must be comprised of a single PEM block of
    /// type "PUBLIC KEY".
    pub public_key: std::string::String,

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

impl AzureConfigEncryption {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Configuration for Azure Disks.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureDiskTemplate {
    /// Optional. The size of the disk, in GiBs.
    ///
    /// When unspecified, a default value is provided. See the specific reference
    /// in the parent resource.
    pub size_gib: i32,

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

impl AzureDiskTemplate {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// `AzureClient` resources hold client authentication information needed by the
/// Anthos Multi-Cloud API to manage Azure resources on your Azure subscription.
///
/// When an [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] is
/// created, an `AzureClient` resource needs to be provided and all operations on
/// Azure resources associated to that cluster will authenticate to Azure
/// services using the given client.
///
/// `AzureClient` resources are immutable and cannot be modified upon creation.
///
/// Each `AzureClient` resource is bound to a single Azure Active Directory
/// Application and tenant.
///
/// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClient {
    /// The name of this resource.
    ///
    /// `AzureClient` resource names are formatted as
    /// `projects/<project-number>/locations/<region>/azureClients/<client-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    pub name: std::string::String,

    /// Required. The Azure Active Directory Tenant ID.
    pub tenant_id: std::string::String,

    /// Required. The Azure Active Directory Application ID.
    pub application_id: std::string::String,

    /// Output only. If set, there are currently pending changes to the client.
    pub reconciling: bool,

    /// Optional. Annotations on the resource.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Keys can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. The PEM encoded x509 certificate.
    pub pem_certificate: std::string::String,

    /// Output only. A globally unique identifier for the client.
    pub uid: std::string::String,

    /// Output only. The time at which this resource was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this client was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

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

impl AzureClient {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AzureClient::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClient;
    /// let x = AzureClient::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 [tenant_id][crate::model::AzureClient::tenant_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClient;
    /// let x = AzureClient::new().set_tenant_id("example");
    /// ```
    pub fn set_tenant_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.tenant_id = v.into();
        self
    }

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

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

    /// Sets the value of [annotations][crate::model::AzureClient::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClient;
    /// let x = AzureClient::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

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

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

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

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

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

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

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

/// Configuration related to the cluster RBAC settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureAuthorization {
    /// Optional. Users that can perform operations as a cluster admin. A managed
    /// ClusterRoleBinding will be created to grant the `cluster-admin` ClusterRole
    /// to the users. Up to ten admin users can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_users: std::vec::Vec<crate::model::AzureClusterUser>,

    /// Optional. Groups of users that can perform operations as a cluster admin. A
    /// managed ClusterRoleBinding will be created to grant the `cluster-admin`
    /// ClusterRole to the groups. Up to ten admin groups can be provided.
    ///
    /// For more info on RBAC, see
    /// <https://kubernetes.io/docs/reference/access-authn-authz/rbac/#user-facing-roles>
    pub admin_groups: std::vec::Vec<crate::model::AzureClusterGroup>,

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

impl AzureAuthorization {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Authentication configuration for the management of Azure resources.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureServicesAuthentication {
    /// Required. The Azure Active Directory Tenant ID.
    pub tenant_id: std::string::String,

    /// Required. The Azure Active Directory Application ID.
    pub application_id: std::string::String,

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

impl AzureServicesAuthentication {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// Identities of a user-type subject for Azure clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClusterUser {
    /// Required. The name of the user, e.g. `my-gcp-id@gmail.com`.
    pub username: std::string::String,

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

impl AzureClusterUser {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Identities of a group-type subject for Azure clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClusterGroup {
    /// Required. The name of the group, e.g. `my-group@domain.com`.
    pub group: std::string::String,

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

impl AzureClusterGroup {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// An Anthos node pool running on Azure.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureNodePool {
    /// The name of this resource.
    ///
    /// Node pool names are formatted as
    /// `projects/<project-number>/locations/<region>/azureClusters/<cluster-id>/azureNodePools/<node-pool-id>`.
    ///
    /// For more details on Google Cloud resource names,
    /// see [Resource Names](https://cloud.google.com/apis/design/resource_names)
    pub name: std::string::String,

    /// Required. The Kubernetes version (e.g. `1.19.10-gke.1000`) running on this
    /// node pool.
    pub version: std::string::String,

    /// Required. The node configuration of the node pool.
    pub config: std::option::Option<crate::model::AzureNodeConfig>,

    /// Required. The ARM ID of the subnet where the node pool VMs run. Make sure
    /// it's a subnet under the virtual network in the cluster configuration.
    pub subnet_id: std::string::String,

    /// Required. Autoscaler configuration for this node pool.
    pub autoscaling: std::option::Option<crate::model::AzureNodePoolAutoscaling>,

    /// Output only. The current state of the node pool.
    pub state: crate::model::azure_node_pool::State,

    /// Output only. A globally unique identifier for the node pool.
    pub uid: std::string::String,

    /// Output only. If set, there are currently pending changes to the node
    /// pool.
    pub reconciling: bool,

    /// Output only. The time at which this node pool was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this node pool was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Allows clients to perform consistent read-modify-writes
    /// through optimistic concurrency control.
    ///
    /// Can be sent on update and delete requests to ensure the
    /// client has an up-to-date value before proceeding.
    pub etag: std::string::String,

    /// Optional. Annotations on the node pool.
    ///
    /// This field has the same restrictions as Kubernetes annotations.
    /// The total size of all keys and values combined is limited to 256k.
    /// Keys can have 2 segments: prefix (optional) and name (required),
    /// separated by a slash (/).
    /// Prefix must be a DNS subdomain.
    /// Name must be 63 characters or less, begin and end with alphanumerics,
    /// with dashes (-), underscores (_), dots (.), and alphanumerics between.
    pub annotations: std::collections::HashMap<std::string::String, std::string::String>,

    /// Required. 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>,

    /// Optional. The Azure availability zone of the nodes in this nodepool.
    ///
    /// When unspecified, it defaults to `1`.
    pub azure_availability_zone: std::string::String,

    /// Output only. A set of errors found in the node pool.
    pub errors: std::vec::Vec<crate::model::AzureNodePoolError>,

    /// Optional. The Management configuration for this node pool.
    pub management: std::option::Option<crate::model::AzureNodeManagement>,

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

impl AzureNodePool {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AzureNodePool::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = AzureNodePool::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::AzureNodePool::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = AzureNodePool::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 [config][crate::model::AzureNodePool::config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// let x = AzureNodePool::new().set_config(AzureNodeConfig::default()/* use setters */);
    /// ```
    pub fn set_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureNodeConfig>,
    {
        self.config = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

    /// Sets the value of [state][crate::model::AzureNodePool::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// use google_cloud_gkemulticloud_v1::model::azure_node_pool::State;
    /// let x0 = AzureNodePool::new().set_state(State::Provisioning);
    /// let x1 = AzureNodePool::new().set_state(State::Running);
    /// let x2 = AzureNodePool::new().set_state(State::Reconciling);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::azure_node_pool::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

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

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

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

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

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

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

    /// Sets the value of [etag][crate::model::AzureNodePool::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = AzureNodePool::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 [annotations][crate::model::AzureNodePool::annotations].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = AzureNodePool::new().set_annotations([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_annotations<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.annotations = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [max_pods_constraint][crate::model::AzureNodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// use google_cloud_gkemulticloud_v1::model::MaxPodsConstraint;
    /// let x = AzureNodePool::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::AzureNodePool::max_pods_constraint].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// use google_cloud_gkemulticloud_v1::model::MaxPodsConstraint;
    /// let x = AzureNodePool::new().set_or_clear_max_pods_constraint(Some(MaxPodsConstraint::default()/* use setters */));
    /// let x = AzureNodePool::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 [azure_availability_zone][crate::model::AzureNodePool::azure_availability_zone].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = AzureNodePool::new().set_azure_availability_zone("example");
    /// ```
    pub fn set_azure_availability_zone<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.azure_availability_zone = v.into();
        self
    }

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

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

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

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

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

    /// The lifecycle state of 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// 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 RECONCILING state indicates that the node pool is being reconciled.
        Reconciling,
        /// The STOPPING state indicates the node pool is being deleted.
        Stopping,
        /// The ERROR state indicates the node pool is in a broken unrecoverable
        /// state.
        Error,
        /// The DEGRADED state indicates the node pool requires user action to
        /// restore full functionality.
        Degraded,
        /// 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::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("STATE_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 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::Provisioning,
                2 => Self::Running,
                3 => Self::Reconciling,
                4 => Self::Stopping,
                5 => Self::Error,
                6 => Self::Degraded,
                _ => 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,
                "PROVISIONING" => Self::Provisioning,
                "RUNNING" => Self::Running,
                "RECONCILING" => Self::Reconciling,
                "STOPPING" => Self::Stopping,
                "ERROR" => Self::Error,
                "DEGRADED" => Self::Degraded,
                _ => 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::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 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.cloud.gkemulticloud.v1.AzureNodePool.State",
            ))
        }
    }
}

/// AzureNodeManagement defines the set of node management features turned on for
/// an Azure node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureNodeManagement {
    /// Optional. Whether or not the nodes will be automatically repaired. When set
    /// to true, the nodes in this node pool will be monitored and if they fail
    /// health checks consistently over a period of time, an automatic repair
    /// action will be triggered to replace them with new nodes.
    pub auto_repair: bool,

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

impl AzureNodeManagement {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [auto_repair][crate::model::AzureNodeManagement::auto_repair].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeManagement;
    /// let x = AzureNodeManagement::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
    }
}

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

/// Parameters that describe the configuration of all node machines
/// on a given node pool.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureNodeConfig {
    /// Optional. The Azure VM size name. Example: `Standard_DS2_v2`.
    ///
    /// See [Supported VM
    /// sizes](/anthos/clusters/docs/azure/reference/supported-vms) for options.
    ///
    /// When unspecified, it defaults to `Standard_DS2_v2`.
    pub vm_size: std::string::String,

    /// Optional. Configuration related to the root volume provisioned for each
    /// node pool machine.
    ///
    /// When unspecified, it defaults to a 32-GiB Azure Disk.
    pub root_volume: std::option::Option<crate::model::AzureDiskTemplate>,

    /// Optional. A set of tags to apply to all underlying Azure resources for this
    /// node pool. This currently only includes Virtual Machine Scale Sets.
    ///
    /// Specify at most 50 pairs containing alphanumerics, spaces, and symbols
    /// (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to
    /// 255 Unicode characters.
    pub tags: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. The OS image type to use on node pool instances.
    /// Can be unspecified, or have a value of `ubuntu`.
    ///
    /// When unspecified, it defaults to `ubuntu`.
    pub image_type: std::string::String,

    /// Required. SSH configuration for how to access the node pool machines.
    pub ssh_config: std::option::Option<crate::model::AzureSshConfig>,

    /// Optional. Proxy configuration for outbound HTTP(S) traffic.
    pub proxy_config: std::option::Option<crate::model::AzureProxyConfig>,

    /// Optional. Configuration related to vm config encryption.
    pub config_encryption: std::option::Option<crate::model::AzureConfigEncryption>,

    /// Optional. The initial taints assigned to nodes of this node pool.
    pub taints: std::vec::Vec<crate::model::NodeTaint>,

    /// Optional. The initial labels assigned to nodes of this node pool. An object
    /// containing a list of "key": value pairs. Example: { "name": "wrench",
    /// "mass": "1.3kg", "count": "3" }.
    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 AzureNodeConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [tags][crate::model::AzureNodeConfig::tags].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// let x = AzureNodeConfig::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
    }

    /// Sets the value of [image_type][crate::model::AzureNodeConfig::image_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// let x = AzureNodeConfig::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 [ssh_config][crate::model::AzureNodeConfig::ssh_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// use google_cloud_gkemulticloud_v1::model::AzureSshConfig;
    /// let x = AzureNodeConfig::new().set_ssh_config(AzureSshConfig::default()/* use setters */);
    /// ```
    pub fn set_ssh_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureSshConfig>,
    {
        self.ssh_config = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

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

    /// Sets the value of [taints][crate::model::AzureNodeConfig::taints].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// use google_cloud_gkemulticloud_v1::model::NodeTaint;
    /// let x = AzureNodeConfig::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 [labels][crate::model::AzureNodeConfig::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodeConfig;
    /// let x = AzureNodeConfig::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 AzureNodeConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.AzureNodeConfig"
    }
}

/// Configuration related to Kubernetes cluster autoscaler.
///
/// The Kubernetes cluster autoscaler will automatically adjust the
/// size of the node pool based on the cluster load.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureNodePoolAutoscaling {
    /// Required. Minimum number of nodes in the node pool. Must be greater than or
    /// equal to 1 and less than or equal to max_node_count.
    pub min_node_count: i32,

    /// Required. Maximum number of nodes in the node pool. Must be greater than or
    /// equal to min_node_count and less than or equal to 50.
    pub max_node_count: i32,

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

impl AzureNodePoolAutoscaling {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [min_node_count][crate::model::AzureNodePoolAutoscaling::min_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePoolAutoscaling;
    /// let x = AzureNodePoolAutoscaling::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::AzureNodePoolAutoscaling::max_node_count].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePoolAutoscaling;
    /// let x = AzureNodePoolAutoscaling::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
    }
}

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

/// AzureOpenIdConfig is an OIDC discovery document for the cluster.
/// See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureOpenIdConfig {
    /// 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 AzureOpenIdConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [issuer][crate::model::AzureOpenIdConfig::issuer].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::jwks_uri].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::response_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::subject_types_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::id_token_signing_alg_values_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::claims_supported].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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::AzureOpenIdConfig::grant_types].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureOpenIdConfig;
    /// let x = AzureOpenIdConfig::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 AzureOpenIdConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.AzureOpenIdConfig"
    }
}

/// AzureJsonWebKeys is a valid JSON Web Key Set as specififed in RFC 7517.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureJsonWebKeys {
    /// 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 AzureJsonWebKeys {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [keys][crate::model::AzureJsonWebKeys::keys].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureJsonWebKeys;
    /// use google_cloud_gkemulticloud_v1::model::Jwk;
    /// let x = AzureJsonWebKeys::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 AzureJsonWebKeys {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.AzureJsonWebKeys"
    }
}

/// AzureServerConfig contains information about a Google Cloud location, such as
/// supported Azure regions and Kubernetes versions.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureServerConfig {
    /// The `AzureServerConfig` resource name.
    ///
    /// `AzureServerConfig` names are formatted as
    /// `projects/<project-number>/locations/<region>/azureServerConfig`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    pub name: std::string::String,

    /// List of all released Kubernetes versions, including ones which are end of
    /// life and can no longer be used.  Filter by the `enabled`
    /// property to limit to currently available versions.
    /// Valid versions supported for both create and update operations
    pub valid_versions: std::vec::Vec<crate::model::AzureK8sVersionInfo>,

    /// The list of supported Azure regions.
    pub supported_azure_regions: std::vec::Vec<std::string::String>,

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

impl AzureServerConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::AzureServerConfig::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureServerConfig;
    /// let x = AzureServerConfig::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 [valid_versions][crate::model::AzureServerConfig::valid_versions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureServerConfig;
    /// use google_cloud_gkemulticloud_v1::model::AzureK8sVersionInfo;
    /// let x = AzureServerConfig::new()
    ///     .set_valid_versions([
    ///         AzureK8sVersionInfo::default()/* use setters */,
    ///         AzureK8sVersionInfo::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_valid_versions<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::AzureK8sVersionInfo>,
    {
        use std::iter::Iterator;
        self.valid_versions = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [supported_azure_regions][crate::model::AzureServerConfig::supported_azure_regions].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureServerConfig;
    /// let x = AzureServerConfig::new().set_supported_azure_regions(["a", "b", "c"]);
    /// ```
    pub fn set_supported_azure_regions<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.supported_azure_regions = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

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

/// Kubernetes version information of GKE cluster on Azure.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureK8sVersionInfo {
    /// Kubernetes version name (for example, `1.19.10-gke.1000`)
    pub version: std::string::String,

    /// Optional. True if the version is available for cluster creation. If a
    /// version is enabled for creation, it can be used to create new clusters.
    /// Otherwise, cluster creation will fail. However, cluster upgrade operations
    /// may succeed, even if the version is not enabled.
    pub enabled: bool,

    /// Optional. True if this cluster version belongs to a minor version that has
    /// reached its end of life and is no longer in scope to receive security and
    /// bug fixes.
    pub end_of_life: bool,

    /// Optional. The estimated date (in Pacific Time) when this cluster version
    /// will reach its end of life. Or if this version is no longer supported (the
    /// `end_of_life` field is true), this is the actual date (in Pacific time)
    /// when the version reached its end of life.
    pub end_of_life_date: std::option::Option<google_cloud_type::model::Date>,

    /// Optional. The date (in Pacific Time) when the cluster version was released.
    pub release_date: std::option::Option<google_cloud_type::model::Date>,

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

impl AzureK8sVersionInfo {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [version][crate::model::AzureK8sVersionInfo::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureK8sVersionInfo;
    /// let x = AzureK8sVersionInfo::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 [enabled][crate::model::AzureK8sVersionInfo::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureK8sVersionInfo;
    /// let x = AzureK8sVersionInfo::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 [end_of_life][crate::model::AzureK8sVersionInfo::end_of_life].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureK8sVersionInfo;
    /// let x = AzureK8sVersionInfo::new().set_end_of_life(true);
    /// ```
    pub fn set_end_of_life<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.end_of_life = v.into();
        self
    }

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

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

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

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

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

/// SSH configuration for Azure resources.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureSshConfig {
    /// Required. The SSH public key data for VMs managed by Anthos. This accepts
    /// the authorized_keys file format used in OpenSSH according to the sshd(8)
    /// manual page.
    pub authorized_key: std::string::String,

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

impl AzureSshConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Managed Azure resources for the cluster.
///
/// The values could change and be empty, depending on the state of the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClusterResources {
    /// Output only. The ARM ID of the cluster network security group.
    pub network_security_group_id: std::string::String,

    /// Output only. The ARM ID of the control plane application security group.
    pub control_plane_application_security_group_id: std::string::String,

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

impl AzureClusterResources {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

/// AzureClusterError describes errors found on Azure clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureClusterError {
    /// Human-friendly description of the error.
    pub message: std::string::String,

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

impl AzureClusterError {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message][crate::model::AzureClusterError::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureClusterError;
    /// let x = AzureClusterError::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
    }
}

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

/// AzureNodePoolError describes errors found on Azure node pools.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct AzureNodePoolError {
    /// Human-friendly description of the error.
    pub message: std::string::String,

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

impl AzureNodePoolError {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [message][crate::model::AzureNodePoolError::message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::AzureNodePoolError;
    /// let x = AzureNodePoolError::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
    }
}

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

/// Request message for `AzureClusters.CreateAzureCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CreateAzureClusterRequest {
    /// Required. The parent location where this
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource will be
    /// created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub azure_cluster: std::option::Option<crate::model::AzureCluster>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource name
    /// formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub azure_cluster_id: std::string::String,

    /// If set, only validate the request, but do not actually create the cluster.
    pub validate_only: bool,

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

impl CreateAzureClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAzureClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureClusterRequest;
    /// let x = CreateAzureClusterRequest::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 [azure_cluster][crate::model::CreateAzureClusterRequest::azure_cluster].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureClusterRequest;
    /// use google_cloud_gkemulticloud_v1::model::AzureCluster;
    /// let x = CreateAzureClusterRequest::new().set_azure_cluster(AzureCluster::default()/* use setters */);
    /// ```
    pub fn set_azure_cluster<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureCluster>,
    {
        self.azure_cluster = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AzureClusters.UpdateAzureCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct UpdateAzureClusterRequest {
    /// Required. The [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster]
    /// resource to update.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub azure_cluster: std::option::Option<crate::model::AzureCluster>,

    /// If set, only validate the request, but do not actually update the cluster.
    pub validate_only: bool,

    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field can only include these
    /// fields from [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster]:
    ///
    /// * `description`.
    /// * `azureClient`.
    /// * `control_plane.version`.
    /// * `control_plane.vm_size`.
    /// * `annotations`.
    /// * `authorization.admin_users`.
    /// * `authorization.admin_groups`.
    /// * `control_plane.root_volume.size_gib`.
    /// * `azure_services_authentication`.
    /// * `azure_services_authentication.tenant_id`.
    /// * `azure_services_authentication.application_id`.
    /// * `control_plane.proxy_config`.
    /// * `control_plane.proxy_config.resource_group_id`.
    /// * `control_plane.proxy_config.secret_id`.
    /// * `control_plane.ssh_config.authorized_key`.
    /// * `logging_config.component_config.enable_components`
    /// * `monitoring_config.managed_prometheus_config.enabled`.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

impl UpdateAzureClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

/// Request message for `AzureClusters.GetAzureCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAzureClusterRequest {
    /// Required. The name of the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource to
    /// describe.
    ///
    /// `AzureCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub name: std::string::String,

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

impl GetAzureClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAzureClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAzureClusterRequest;
    /// let x = GetAzureClusterRequest::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 GetAzureClusterRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAzureClusterRequest"
    }
}

/// Request message for `AzureClusters.ListAzureClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureClustersRequest {
    /// Required. The parent location which owns this collection of
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resources.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAzureClustersResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAzureClustersResponse.next_page_token]: crate::model::ListAzureClustersResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [azureClusters.list][google.cloud.gkemulticloud.v1.AzureClusters.ListAzureClusters]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClusters.ListAzureClusters]: crate::client::AzureClusters::list_azure_clusters
    pub page_token: std::string::String,

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

impl ListAzureClustersRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAzureClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClustersRequest;
    /// let x = ListAzureClustersRequest::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 [page_size][crate::model::ListAzureClustersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClustersRequest;
    /// let x = ListAzureClustersRequest::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::ListAzureClustersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClustersRequest;
    /// let x = ListAzureClustersRequest::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 ListAzureClustersRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureClustersRequest"
    }
}

/// Response message for `AzureClusters.ListAzureClusters` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureClustersResponse {
    /// A list of [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster]
    /// resources in the specified Google Cloud Platform project and region region.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub azure_clusters: std::vec::Vec<crate::model::AzureCluster>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAzureClustersResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAzureClustersResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClustersResponse;
    /// let x = ListAzureClustersResponse::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 ListAzureClustersResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureClustersResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAzureClustersResponse {
    type PageItem = crate::model::AzureCluster;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.azure_clusters
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AzureClusters.DeleteAzureCluster` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DeleteAzureClusterRequest {
    /// Required. The resource name the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] to delete.
    ///
    /// `AzureCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub name: std::string::String,

    /// If set to true, and the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource is not
    /// found, the request will succeed but no action will be taken on the server
    /// and a completed [Operation][google.longrunning.Operation] will be returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// If set, only validate the request, but do not actually delete the resource.
    pub validate_only: bool,

    /// The current etag of the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster].
    ///
    /// Allows clients to perform deletions through optimistic concurrency control.
    ///
    /// If the provided etag does not match the current etag of the cluster,
    /// the request will fail and an ABORTED error will be returned.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub etag: std::string::String,

    /// Optional. If set to true, the deletion of
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource will
    /// succeed even if errors occur during deleting in cluster resources. Using
    /// this parameter may result in orphaned resources in the cluster.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub ignore_errors: bool,

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

impl DeleteAzureClusterRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAzureClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClusterRequest;
    /// let x = DeleteAzureClusterRequest::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 [allow_missing][crate::model::DeleteAzureClusterRequest::allow_missing].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClusterRequest;
    /// let x = DeleteAzureClusterRequest::new().set_allow_missing(true);
    /// ```
    pub fn set_allow_missing<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.allow_missing = v.into();
        self
    }

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

    /// Sets the value of [etag][crate::model::DeleteAzureClusterRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClusterRequest;
    /// let x = DeleteAzureClusterRequest::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 [ignore_errors][crate::model::DeleteAzureClusterRequest::ignore_errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClusterRequest;
    /// let x = DeleteAzureClusterRequest::new().set_ignore_errors(true);
    /// ```
    pub fn set_ignore_errors<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.ignore_errors = v.into();
        self
    }
}

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

/// Response message for `AzureClusters.CreateAzureNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CreateAzureNodePoolRequest {
    /// Required. The [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster]
    /// resource where this node pool will be created.
    ///
    /// `AzureCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub azure_node_pool: std::option::Option<crate::model::AzureNodePool>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] resource name
    /// formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>/azureNodePools/<node-pool-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub azure_node_pool_id: std::string::String,

    /// If set, only validate the request, but do not actually create the node
    /// pool.
    pub validate_only: bool,

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

impl CreateAzureNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAzureNodePoolRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureNodePoolRequest;
    /// let x = CreateAzureNodePoolRequest::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 [azure_node_pool][crate::model::CreateAzureNodePoolRequest::azure_node_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureNodePoolRequest;
    /// use google_cloud_gkemulticloud_v1::model::AzureNodePool;
    /// let x = CreateAzureNodePoolRequest::new().set_azure_node_pool(AzureNodePool::default()/* use setters */);
    /// ```
    pub fn set_azure_node_pool<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureNodePool>,
    {
        self.azure_node_pool = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AzureClusters.UpdateAzureNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct UpdateAzureNodePoolRequest {
    /// Required. The [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool]
    /// resource to update.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub azure_node_pool: std::option::Option<crate::model::AzureNodePool>,

    /// If set, only validate the request, but don't actually update the node pool.
    pub validate_only: bool,

    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field. The elements of the repeated paths field can only include these
    /// fields from [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool]:
    ///
    /// *.  `annotations`.
    ///
    /// * `version`.
    /// * `autoscaling.min_node_count`.
    /// * `autoscaling.max_node_count`.
    /// * `config.ssh_config.authorized_key`.
    /// * `management.auto_repair`.
    /// * `management`.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub update_mask: std::option::Option<wkt::FieldMask>,

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

impl UpdateAzureNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

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

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

/// Request message for `AzureClusters.GetAzureNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAzureNodePoolRequest {
    /// Required. The name of the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] resource to
    /// describe.
    ///
    /// `AzureNodePool` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>/azureNodePools/<node-pool-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub name: std::string::String,

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

impl GetAzureNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAzureNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAzureNodePoolRequest;
    /// let x = GetAzureNodePoolRequest::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 GetAzureNodePoolRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAzureNodePoolRequest"
    }
}

/// Request message for `AzureClusters.ListAzureNodePools` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureNodePoolsRequest {
    /// Required. The parent `AzureCluster` which owns this collection of
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] resources.
    ///
    /// `AzureCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAzureNodePoolsResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAzureNodePoolsResponse.next_page_token]: crate::model::ListAzureNodePoolsResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [azureNodePools.list][google.cloud.gkemulticloud.v1.AzureClusters.ListAzureNodePools]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClusters.ListAzureNodePools]: crate::client::AzureClusters::list_azure_node_pools
    pub page_token: std::string::String,

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

impl ListAzureNodePoolsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAzureNodePoolsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureNodePoolsRequest;
    /// let x = ListAzureNodePoolsRequest::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 [page_size][crate::model::ListAzureNodePoolsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureNodePoolsRequest;
    /// let x = ListAzureNodePoolsRequest::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::ListAzureNodePoolsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureNodePoolsRequest;
    /// let x = ListAzureNodePoolsRequest::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 ListAzureNodePoolsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureNodePoolsRequest"
    }
}

/// Response message for `AzureClusters.ListAzureNodePools` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureNodePoolsResponse {
    /// A list of [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool]
    /// resources in the specified `AzureCluster`.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub azure_node_pools: std::vec::Vec<crate::model::AzureNodePool>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAzureNodePoolsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAzureNodePoolsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureNodePoolsResponse;
    /// let x = ListAzureNodePoolsResponse::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 ListAzureNodePoolsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureNodePoolsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAzureNodePoolsResponse {
    type PageItem = crate::model::AzureNodePool;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.azure_node_pools
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AzureClusters.DeleteAzureNodePool` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DeleteAzureNodePoolRequest {
    /// Required. The resource name the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] to delete.
    ///
    /// `AzureNodePool` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>/azureNodePools/<node-pool-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub name: std::string::String,

    /// If set, only validate the request, but do not actually delete the node
    /// pool.
    pub validate_only: bool,

    /// If set to true, and the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] resource is
    /// not found, the request will succeed but no action will be taken on the
    /// server and a completed [Operation][google.longrunning.Operation] will be
    /// returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// The current ETag of the
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool].
    ///
    /// Allows clients to perform deletions through optimistic concurrency control.
    ///
    /// If the provided ETag does not match the current etag of the node pool,
    /// the request will fail and an ABORTED error will be returned.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub etag: std::string::String,

    /// Optional. If set to true, the deletion of
    /// [AzureNodePool][google.cloud.gkemulticloud.v1.AzureNodePool] resource will
    /// succeed even if errors occur during deleting in node pool resources. Using
    /// this parameter may result in orphaned resources in the node pool.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureNodePool]: crate::model::AzureNodePool
    pub ignore_errors: bool,

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

impl DeleteAzureNodePoolRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAzureNodePoolRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureNodePoolRequest;
    /// let x = DeleteAzureNodePoolRequest::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 [validate_only][crate::model::DeleteAzureNodePoolRequest::validate_only].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureNodePoolRequest;
    /// let x = DeleteAzureNodePoolRequest::new().set_validate_only(true);
    /// ```
    pub fn set_validate_only<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.validate_only = v.into();
        self
    }

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

    /// Sets the value of [etag][crate::model::DeleteAzureNodePoolRequest::etag].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureNodePoolRequest;
    /// let x = DeleteAzureNodePoolRequest::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 [ignore_errors][crate::model::DeleteAzureNodePoolRequest::ignore_errors].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureNodePoolRequest;
    /// let x = DeleteAzureNodePoolRequest::new().set_ignore_errors(true);
    /// ```
    pub fn set_ignore_errors<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.ignore_errors = v.into();
        self
    }
}

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

/// GetAzureOpenIdConfigRequest gets the OIDC discovery document for the
/// cluster. See the OpenID Connect Discovery 1.0 specification for details.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAzureOpenIdConfigRequest {
    /// Required. The AzureCluster, which owns the OIDC discovery document.
    /// Format:
    /// projects/\<project-id\>/locations/\<region\>/azureClusters/\<cluster-id\>
    pub azure_cluster: std::string::String,

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

impl GetAzureOpenIdConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// GetAzureJsonWebKeysRequest 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]
#[deprecated]
pub struct GetAzureJsonWebKeysRequest {
    /// Required. The AzureCluster, which owns the JsonWebKeys.
    /// Format:
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`
    pub azure_cluster: std::string::String,

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

impl GetAzureJsonWebKeysRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// GetAzureServerConfigRequest gets the server config of GKE cluster on Azure.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAzureServerConfigRequest {
    /// Required. The name of the
    /// [AzureServerConfig][google.cloud.gkemulticloud.v1.AzureServerConfig]
    /// resource to describe.
    ///
    /// `AzureServerConfig` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureServerConfig`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureServerConfig]: crate::model::AzureServerConfig
    pub name: std::string::String,

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

impl GetAzureServerConfigRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAzureServerConfigRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAzureServerConfigRequest;
    /// let x = GetAzureServerConfigRequest::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 GetAzureServerConfigRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAzureServerConfigRequest"
    }
}

/// Request message for `AzureClusters.CreateAzureClient` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct CreateAzureClientRequest {
    /// Required. The parent location where this
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] resource will be
    /// created.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub parent: std::string::String,

    /// Required. The specification of the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] to create.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub azure_client: std::option::Option<crate::model::AzureClient>,

    /// Required. A client provided ID the resource. Must be unique within the
    /// parent resource.
    ///
    /// The provided ID will be part of the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] resource name
    /// formatted as
    /// `projects/<project-id>/locations/<region>/azureClients/<client-id>`.
    ///
    /// Valid characters are `/[a-z][0-9]-/`. Cannot be longer than 63 characters.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub azure_client_id: std::string::String,

    /// If set, only validate the request, but do not actually create the client.
    pub validate_only: bool,

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

impl CreateAzureClientRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateAzureClientRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureClientRequest;
    /// let x = CreateAzureClientRequest::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 [azure_client][crate::model::CreateAzureClientRequest::azure_client].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CreateAzureClientRequest;
    /// use google_cloud_gkemulticloud_v1::model::AzureClient;
    /// let x = CreateAzureClientRequest::new().set_azure_client(AzureClient::default()/* use setters */);
    /// ```
    pub fn set_azure_client<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::AzureClient>,
    {
        self.azure_client = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Request message for `AzureClusters.GetAzureClient` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GetAzureClientRequest {
    /// Required. The name of the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] resource to
    /// describe.
    ///
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] names are
    /// formatted as
    /// `projects/<project-id>/locations/<region>/azureClients/<client-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub name: std::string::String,

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

impl GetAzureClientRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetAzureClientRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GetAzureClientRequest;
    /// let x = GetAzureClientRequest::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 GetAzureClientRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.GetAzureClientRequest"
    }
}

/// Request message for `AzureClusters.ListAzureClients` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureClientsRequest {
    /// Required. The parent location which owns this collection of
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] resources.
    ///
    /// Location names are formatted as `projects/<project-id>/locations/<region>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud Platform resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub parent: std::string::String,

    /// The maximum number of items to return.
    ///
    /// If not specified, a default value of 50 will be used by the service.
    /// Regardless of the pageSize value, the response can include a partial list
    /// and a caller should only rely on response's
    /// [nextPageToken][google.cloud.gkemulticloud.v1.ListAzureClientsResponse.next_page_token]
    /// to determine if there are more instances left to be queried.
    ///
    /// [google.cloud.gkemulticloud.v1.ListAzureClientsResponse.next_page_token]: crate::model::ListAzureClientsResponse::next_page_token
    pub page_size: i32,

    /// The `nextPageToken` value returned from a previous
    /// [azureClients.list][google.cloud.gkemulticloud.v1.AzureClusters.ListAzureClients]
    /// request, if any.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClusters.ListAzureClients]: crate::client::AzureClusters::list_azure_clients
    pub page_token: std::string::String,

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

impl ListAzureClientsRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListAzureClientsRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClientsRequest;
    /// let x = ListAzureClientsRequest::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 [page_size][crate::model::ListAzureClientsRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClientsRequest;
    /// let x = ListAzureClientsRequest::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::ListAzureClientsRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClientsRequest;
    /// let x = ListAzureClientsRequest::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 ListAzureClientsRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureClientsRequest"
    }
}

/// Response message for `AzureClusters.ListAzureClients` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct ListAzureClientsResponse {
    /// A list of [AzureClient][google.cloud.gkemulticloud.v1.AzureClient]
    /// resources in the specified Google Cloud project and region region.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub azure_clients: std::vec::Vec<crate::model::AzureClient>,

    /// Token to retrieve the next page of results, or empty if there are no more
    /// results in the list.
    pub next_page_token: std::string::String,

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

impl ListAzureClientsResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [next_page_token][crate::model::ListAzureClientsResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::ListAzureClientsResponse;
    /// let x = ListAzureClientsResponse::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 ListAzureClientsResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.ListAzureClientsResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListAzureClientsResponse {
    type PageItem = crate::model::AzureClient;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.azure_clients
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Request message for `AzureClusters.DeleteAzureClient` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct DeleteAzureClientRequest {
    /// Required. The resource name the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] to delete.
    ///
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] names are
    /// formatted as
    /// `projects/<project-id>/locations/<region>/azureClients/<client-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    pub name: std::string::String,

    /// If set to true, and the
    /// [AzureClient][google.cloud.gkemulticloud.v1.AzureClient] resource is not
    /// found, the request will succeed but no action will be taken on the server
    /// and a completed [Operation][google.longrunning.Operation] will be returned.
    ///
    /// Useful for idempotent deletion.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureClient]: crate::model::AzureClient
    /// [google.longrunning.Operation]: google_cloud_longrunning::model::Operation
    pub allow_missing: bool,

    /// If set, only validate the request, but do not actually delete the resource.
    pub validate_only: bool,

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

impl DeleteAzureClientRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteAzureClientRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClientRequest;
    /// let x = DeleteAzureClientRequest::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 [allow_missing][crate::model::DeleteAzureClientRequest::allow_missing].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::DeleteAzureClientRequest;
    /// let x = DeleteAzureClientRequest::new().set_allow_missing(true);
    /// ```
    pub fn set_allow_missing<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.allow_missing = v.into();
        self
    }

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

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

/// Request message for `AzureClusters.GenerateAzureAccessToken` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAzureAccessTokenRequest {
    /// Required. The name of the
    /// [AzureCluster][google.cloud.gkemulticloud.v1.AzureCluster] resource to
    /// authenticate to.
    ///
    /// `AzureCluster` names are formatted as
    /// `projects/<project-id>/locations/<region>/azureClusters/<cluster-id>`.
    ///
    /// See [Resource Names](https://cloud.google.com/apis/design/resource_names)
    /// for more details on Google Cloud resource names.
    ///
    /// [google.cloud.gkemulticloud.v1.AzureCluster]: crate::model::AzureCluster
    pub azure_cluster: std::string::String,

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

impl GenerateAzureAccessTokenRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

/// Response message for `AzureClusters.GenerateAzureAccessToken` method.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAzureAccessTokenResponse {
    /// Output only. Access token to authenticate to k8s api-server.
    pub access_token: std::string::String,

    /// Output only. Timestamp at which the token will expire.
    pub expiration_time: std::option::Option<wkt::Timestamp>,

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

impl GenerateAzureAccessTokenResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAzureClusterAgentTokenRequest {
    /// Required.
    pub azure_cluster: std::string::String,

    /// Required.
    pub subject_token: std::string::String,

    /// Required.
    pub subject_token_type: std::string::String,

    /// Required.
    pub version: std::string::String,

    /// Optional.
    pub node_pool_id: std::string::String,

    /// Optional.
    pub grant_type: std::string::String,

    /// Optional.
    pub audience: std::string::String,

    /// Optional.
    pub scope: std::string::String,

    /// Optional.
    pub requested_token_type: std::string::String,

    /// Optional.
    pub options: std::string::String,

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

impl GenerateAzureClusterAgentTokenRequest {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

    /// Sets the value of [version][crate::model::GenerateAzureClusterAgentTokenRequest::version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAzureClusterAgentTokenRequest;
    /// let x = GenerateAzureClusterAgentTokenRequest::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 [node_pool_id][crate::model::GenerateAzureClusterAgentTokenRequest::node_pool_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAzureClusterAgentTokenRequest;
    /// let x = GenerateAzureClusterAgentTokenRequest::new().set_node_pool_id("example");
    /// ```
    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 [grant_type][crate::model::GenerateAzureClusterAgentTokenRequest::grant_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAzureClusterAgentTokenRequest;
    /// let x = GenerateAzureClusterAgentTokenRequest::new().set_grant_type("example");
    /// ```
    pub fn set_grant_type<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.grant_type = v.into();
        self
    }

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

    /// Sets the value of [scope][crate::model::GenerateAzureClusterAgentTokenRequest::scope].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::GenerateAzureClusterAgentTokenRequest;
    /// let x = GenerateAzureClusterAgentTokenRequest::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
    }

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

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

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

#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
#[deprecated]
pub struct GenerateAzureClusterAgentTokenResponse {
    pub access_token: std::string::String,

    pub expires_in: i32,

    pub token_type: std::string::String,

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

impl GenerateAzureClusterAgentTokenResponse {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

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

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

/// 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 {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [kty][crate::model::Jwk::kty].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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_gkemulticloud_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.cloud.gkemulticloud.v1.Jwk"
    }
}

/// Workload Identity settings.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct WorkloadIdentityConfig {
    /// The OIDC issuer URL for this cluster.
    pub issuer_uri: std::string::String,

    /// The Workload Identity Pool associated to the cluster.
    pub workload_pool: std::string::String,

    /// The ID of the OIDC Identity Provider (IdP) associated to the Workload
    /// Identity Pool.
    pub identity_provider: std::string::String,

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

impl WorkloadIdentityConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

    /// Sets the value of [workload_pool][crate::model::WorkloadIdentityConfig::workload_pool].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_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
    }

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

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

/// Constraints applied to pods.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MaxPodsConstraint {
    /// Required. The maximum number of pods to schedule on a single node.
    pub max_pods_per_node: i64,

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

impl MaxPodsConstraint {
    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_gkemulticloud_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.cloud.gkemulticloud.v1.MaxPodsConstraint"
    }
}

/// Metadata about a long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time at which this operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time at which this operation was completed.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The name of the resource associated to this operation.
    pub target: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    pub status_detail: std::string::String,

    /// Output only. Human-readable status of any error that occurred during the
    /// operation.
    pub error_detail: std::string::String,

    /// Output only. The verb associated with the API method which triggered this
    /// operation. Possible values are "create", "delete", "update" and "import".
    pub verb: std::string::String,

    /// Output only. Identifies whether cancellation has been requested for the
    /// operation. Operations that have successfully been cancelled have
    /// [google.longrunning.Operation.error][google.longrunning.Operation.error]
    /// value with a [google.rpc.Status.code][google.rpc.Status.code] of 1,
    /// corresponding to `Code.CANCELLED`.
    ///
    /// [google.longrunning.Operation.error]: google_cloud_longrunning::model::Operation::result
    /// [google.rpc.Status.code]: google_cloud_rpc::model::Status::code
    pub requested_cancellation: bool,

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

impl OperationMetadata {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::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::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::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 [target][crate::model::OperationMetadata::target].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_target("example");
    /// ```
    pub fn set_target<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target = v.into();
        self
    }

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

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

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

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

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

/// The taint content for the node taint.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeTaint {
    /// Required. Key for the taint.
    pub key: std::string::String,

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

    /// Required. The taint effect.
    pub effect: crate::model::node_taint::Effect,

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

impl NodeTaint {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [key][crate::model::NodeTaint::key].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_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_gkemulticloud_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_gkemulticloud_v1::model::NodeTaint;
    /// use google_cloud_gkemulticloud_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.cloud.gkemulticloud.v1.NodeTaint"
    }
}

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

    /// The taint effect.
    ///
    /// # 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Effect {
        /// Not set.
        Unspecified,
        /// Do not allow new pods to schedule onto the node unless they tolerate the
        /// taint, but allow all pods submitted to Kubelet without going through the
        /// scheduler to start, and allow all already-running pods to continue
        /// running. Enforced by the scheduler.
        NoSchedule,
        /// Like TaintEffectNoSchedule, but the scheduler tries not to schedule
        /// new pods onto the node, rather than prohibiting new pods from scheduling
        /// onto the node entirely. Enforced by the scheduler.
        PreferNoSchedule,
        /// Evict any already-running pods that do not tolerate the taint.
        /// Currently enforced by NodeController.
        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.cloud.gkemulticloud.v1.NodeTaint.Effect",
            ))
        }
    }
}

/// Configuration for node pool kubelet options.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NodeKubeletConfig {
    /// Optional. Enable the insecure kubelet read only port.
    pub insecure_kubelet_readonly_port_enabled: bool,

    /// Optional. 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::option::Option<std::string::String>,

    /// Optional. 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<bool>,

    /// Optional. 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.
    ///
    /// The default value is '100ms' if unspecified.
    pub cpu_cfs_quota_period: std::option::Option<std::string::String>,

    /// Optional. 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: std::option::Option<i64>,

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

impl NodeKubeletConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

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

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

    /// Sets or clears the value of [cpu_manager_policy][crate::model::NodeKubeletConfig::cpu_manager_policy].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_manager_policy(Some("example"));
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_manager_policy(None::<String>);
    /// ```
    pub fn set_or_clear_cpu_manager_policy<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.cpu_manager_policy = 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_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_cpu_cfs_quota(true);
    /// ```
    pub fn set_cpu_cfs_quota<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<bool>,
    {
        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_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_cfs_quota(Some(false));
    /// let x = NodeKubeletConfig::new().set_or_clear_cpu_cfs_quota(None::<bool>);
    /// ```
    pub fn set_or_clear_cpu_cfs_quota<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<bool>,
    {
        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_gkemulticloud_v1::model::NodeKubeletConfig;
    /// let x = NodeKubeletConfig::new().set_cpu_cfs_quota_period("example");
    /// ```
    pub fn set_cpu_cfs_quota_period<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<std::string::String>,
    {
        self.cpu_cfs_quota_period = std::option::Option::Some(v.into());
        self
    }

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

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

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

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

/// Fleet related configuration.
///
/// Fleets are a Google Cloud concept for logically organizing clusters,
/// letting you use and manage multi-cluster capabilities and apply
/// consistent policies across your systems.
///
/// See [Anthos
/// Fleets](https://cloud.google.com/anthos/multicluster-management/fleets) for
/// more details on Anthos multi-cluster capabilities using Fleets.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Fleet {
    /// Required. The name of the Fleet host project where this cluster will be
    /// registered.
    ///
    /// Project names are formatted as
    /// `projects/<project-number>`.
    pub project: std::string::String,

    /// Output only. The name of the managed Hub Membership resource associated to
    /// this cluster.
    ///
    /// Membership names are formatted as
    /// `projects/<project-number>/locations/global/membership/<cluster-id>`.
    pub membership: std::string::String,

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

impl Fleet {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [project][crate::model::Fleet::project].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_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_gkemulticloud_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
    }
}

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

/// Parameters that describe the Logging configuration in a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LoggingConfig {
    /// The configuration of the logging components;
    pub component_config: std::option::Option<crate::model::LoggingComponentConfig>,

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

impl LoggingConfig {
    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_gkemulticloud_v1::model::LoggingConfig;
    /// use google_cloud_gkemulticloud_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_gkemulticloud_v1::model::LoggingConfig;
    /// use google_cloud_gkemulticloud_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.cloud.gkemulticloud.v1.LoggingConfig"
    }
}

/// Parameters that describe the Logging component configuration in a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LoggingComponentConfig {
    /// The components to be enabled.
    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 {
    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_gkemulticloud_v1::model::LoggingComponentConfig;
    /// use google_cloud_gkemulticloud_v1::model::logging_component_config::Component;
    /// let x = LoggingComponentConfig::new().set_enable_components([
    ///     Component::SystemComponents,
    ///     Component::Workloads,
    /// ]);
    /// ```
    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.cloud.gkemulticloud.v1.LoggingComponentConfig"
    }
}

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

    /// The components of the logging 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://google-cloud-rust.github.io/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Component {
        /// No component is specified
        Unspecified,
        /// This indicates that system logging components is enabled.
        SystemComponents,
        /// This indicates that user workload logging component is enabled.
        Workloads,
        /// 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::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::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,
                _ => 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,
                _ => 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::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.cloud.gkemulticloud.v1.LoggingComponentConfig.Component",
            ))
        }
    }
}

/// Parameters that describe the Monitoring configuration in a cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct MonitoringConfig {
    /// Enable Google Cloud Managed Service for Prometheus in the cluster.
    pub managed_prometheus_config: std::option::Option<crate::model::ManagedPrometheusConfig>,

    /// Optionally enable GKE metrics.
    /// Only for Attached Clusters.
    pub cloud_monitoring_config: std::option::Option<crate::model::CloudMonitoringConfig>,

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

impl MonitoringConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [managed_prometheus_config][crate::model::MonitoringConfig::managed_prometheus_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// use google_cloud_gkemulticloud_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_gkemulticloud_v1::model::MonitoringConfig;
    /// use google_cloud_gkemulticloud_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 [cloud_monitoring_config][crate::model::MonitoringConfig::cloud_monitoring_config].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::MonitoringConfig;
    /// use google_cloud_gkemulticloud_v1::model::CloudMonitoringConfig;
    /// let x = MonitoringConfig::new().set_cloud_monitoring_config(CloudMonitoringConfig::default()/* use setters */);
    /// ```
    pub fn set_cloud_monitoring_config<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::CloudMonitoringConfig>,
    {
        self.cloud_monitoring_config = std::option::Option::Some(v.into());
        self
    }

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

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

/// 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,

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

impl ManagedPrometheusConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::ManagedPrometheusConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_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
    }
}

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

/// CloudMonitoringConfig defines the configuration for
/// built-in Cloud Logging and Monitoring.
/// Only for Attached Clusters.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CloudMonitoringConfig {
    /// Enable GKE-native logging and metrics.
    /// Only for Attached Clusters.
    pub enabled: std::option::Option<bool>,

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

impl CloudMonitoringConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [enabled][crate::model::CloudMonitoringConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CloudMonitoringConfig;
    /// let x = CloudMonitoringConfig::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::CloudMonitoringConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::CloudMonitoringConfig;
    /// let x = CloudMonitoringConfig::new().set_or_clear_enabled(Some(false));
    /// let x = CloudMonitoringConfig::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 CloudMonitoringConfig {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.gkemulticloud.v1.CloudMonitoringConfig"
    }
}

/// Configuration for Binary Authorization.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BinaryAuthorization {
    /// 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 {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [evaluation_mode][crate::model::BinaryAuthorization::evaluation_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::BinaryAuthorization;
    /// use google_cloud_gkemulticloud_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.cloud.gkemulticloud.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://google-cloud-rust.github.io/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.
        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.cloud.gkemulticloud.v1.BinaryAuthorization.EvaluationMode",
            ))
        }
    }
}

/// 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 vulnerability scanning.
    pub vulnerability_mode: crate::model::security_posture_config::VulnerabilityMode,

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

impl SecurityPostureConfig {
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [vulnerability_mode][crate::model::SecurityPostureConfig::vulnerability_mode].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_gkemulticloud_v1::model::SecurityPostureConfig;
    /// use google_cloud_gkemulticloud_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: std::convert::Into<crate::model::security_posture_config::VulnerabilityMode>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.vulnerability_mode = v.into();
        self
    }
}

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

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

    /// 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://google-cloud-rust.github.io/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,
        /// 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::VulnerabilityEnterprise => 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("VULNERABILITY_MODE_UNSPECIFIED"),
                Self::VulnerabilityDisabled => std::option::Option::Some("VULNERABILITY_DISABLED"),
                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::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_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::VulnerabilityEnterprise => serializer.serialize_i32(2),
                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.cloud.gkemulticloud.v1.SecurityPostureConfig.VulnerabilityMode",
            ))
        }
    }
}