google_cloud_hypercomputecluster_v1/

model.rs

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

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

/// A collection of virtual machines and connected resources forming a
/// high-performance computing cluster capable of running large-scale, tightly
/// coupled workloads. A cluster combines a set a compute resources that perform
/// computations, storage resources that contain inputs and store outputs, an
/// orchestrator that is responsible for assigning jobs to compute resources, and
/// network resources that connect everything together.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Cluster {
    /// Identifier. [Relative resource name](https://google.aip.dev/122) of the
    /// cluster, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    pub name: std::string::String,

    /// Optional. User-provided description of the cluster.
    pub description: std::string::String,

    /// Optional.
    /// [Labels](https://cloud.google.com/compute/docs/labeling-resources) applied
    /// to the cluster. Labels can be used to organize clusters and to filter them
    /// in queries.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Output only. Time that the cluster was originally created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Time that the cluster was most recently updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Indicates whether changes to the cluster are currently in
    /// flight. If this is `true`, then the current state might not match the
    /// cluster's intended state.
    pub reconciling: bool,

    /// Optional. Network resources available to the cluster. Must contain at most
    /// one value. Keys specify the ID of the network resource by which it can be
    /// referenced elsewhere, and must conform to
    /// [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034) (lower-case,
    /// alphanumeric, and at most 63 characters).
    pub network_resources:
        std::collections::HashMap<std::string::String, crate::model::NetworkResource>,

    /// Optional. Storage resources available to the cluster. Keys specify the ID
    /// of the storage resource by which it can be referenced elsewhere, and must
    /// conform to [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034)
    /// (lower-case, alphanumeric, and at most 63 characters).
    pub storage_resources:
        std::collections::HashMap<std::string::String, crate::model::StorageResource>,

    /// Optional. Compute resources available to the cluster. Keys specify the ID
    /// of the compute resource by which it can be referenced elsewhere, and must
    /// conform to [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034)
    /// (lower-case, alphanumeric, and at most 63 characters).
    pub compute_resources:
        std::collections::HashMap<std::string::String, crate::model::ComputeResource>,

    /// Optional. Orchestrator that is responsible for scheduling and running jobs
    /// on the cluster.
    pub orchestrator: std::option::Option<crate::model::Orchestrator>,

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

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

    /// Sets the value of [name][crate::model::Cluster::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let cluster_id = "cluster_id";
    /// let x = Cluster::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

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

    /// Sets the value of [labels][crate::model::Cluster::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// let x = Cluster::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 [create_time][crate::model::Cluster::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use wkt::Timestamp;
    /// let x = Cluster::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::Cluster::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use wkt::Timestamp;
    /// let x = Cluster::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = Cluster::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::Cluster::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use wkt::Timestamp;
    /// let x = Cluster::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::Cluster::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use wkt::Timestamp;
    /// let x = Cluster::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = Cluster::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 [reconciling][crate::model::Cluster::reconciling].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// let x = Cluster::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 [network_resources][crate::model::Cluster::network_resources].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use google_cloud_hypercomputecluster_v1::model::NetworkResource;
    /// let x = Cluster::new().set_network_resources([
    ///     ("key0", NetworkResource::default()/* use setters */),
    ///     ("key1", NetworkResource::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_network_resources<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::NetworkResource>,
    {
        use std::iter::Iterator;
        self.network_resources = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [storage_resources][crate::model::Cluster::storage_resources].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use google_cloud_hypercomputecluster_v1::model::StorageResource;
    /// let x = Cluster::new().set_storage_resources([
    ///     ("key0", StorageResource::default()/* use setters */),
    ///     ("key1", StorageResource::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_storage_resources<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::StorageResource>,
    {
        use std::iter::Iterator;
        self.storage_resources = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [compute_resources][crate::model::Cluster::compute_resources].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Cluster;
    /// use google_cloud_hypercomputecluster_v1::model::ComputeResource;
    /// let x = Cluster::new().set_compute_resources([
    ///     ("key0", ComputeResource::default()/* use setters */),
    ///     ("key1", ComputeResource::default()/* use (different) setters */),
    /// ]);
    /// ```
    pub fn set_compute_resources<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<crate::model::ComputeResource>,
    {
        use std::iter::Iterator;
        self.compute_resources = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

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

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

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

/// Request message for
/// [ListClusters][google.cloud.hypercomputecluster.v1.HypercomputeCluster.ListClusters].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.ListClusters]: crate::client::HypercomputeCluster::list_clusters
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListClustersRequest {
    /// Required. Parent location of the clusters to list, in the format
    /// `projects/{project}/locations/{location}`.
    pub parent: std::string::String,

    /// Optional. Maximum number of clusters to return. The service may return
    /// fewer than this value.
    pub page_size: i32,

    /// Optional. A page token received from a previous `ListClusters` call.
    /// Provide this to retrieve the subsequent page. When paginating, all other
    /// parameters provided to `ListClusters` must match the call that provided the
    /// page token.
    pub page_token: std::string::String,

    /// Optional. [Filter](https://google.aip.dev/160) to apply to the returned
    /// results.
    pub filter: std::string::String,

    /// Optional. How to order the resulting clusters. Must be one of the following
    /// strings:
    ///
    /// * `name`
    /// * `name desc`
    /// * `create_time`
    /// * `create_time desc`
    ///
    /// If not specified, clusters will be returned in an arbitrary order.
    pub order_by: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::ListClustersRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ListClustersRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = ListClustersRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    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::ListClustersRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ListClustersRequest;
    /// let x = ListClustersRequest::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::ListClustersRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ListClustersRequest;
    /// let x = ListClustersRequest::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
    }

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

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

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

/// Response message for
/// [ListClusters][google.cloud.hypercomputecluster.v1.HypercomputeCluster.ListClusters].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.ListClusters]: crate::client::HypercomputeCluster::list_clusters
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListClustersResponse {
    /// Clusters in the specified location.
    pub clusters: std::vec::Vec<crate::model::Cluster>,

    /// A token that can be sent as `page_token` to retrieve the next page. If this
    /// field is absent, there are no subsequent pages.
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    pub unreachable: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

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

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

/// Request message for
/// [GetCluster][google.cloud.hypercomputecluster.v1.HypercomputeCluster.GetCluster].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.GetCluster]: crate::client::HypercomputeCluster::get_cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GetClusterRequest {
    /// Required. Name of the cluster to retrieve, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    pub name: std::string::String,

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

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

    /// Sets the value of [name][crate::model::GetClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::GetClusterRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let cluster_id = "cluster_id";
    /// let x = GetClusterRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

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

/// Request message for
/// [CreateCluster][google.cloud.hypercomputecluster.v1.HypercomputeCluster.CreateCluster].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.CreateCluster]: crate::client::HypercomputeCluster::create_cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateClusterRequest {
    /// Required. Parent location in which the cluster should be created, in the
    /// format `projects/{project}/locations/{location}`.
    pub parent: std::string::String,

    /// Required. ID of the cluster to create. Must conform to
    /// [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034) (lower-case,
    /// alphanumeric, and at most 63 characters).
    pub cluster_id: std::string::String,

    /// Required. Cluster to create.
    pub cluster: std::option::Option<crate::model::Cluster>,

    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    pub request_id: std::string::String,

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

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

    /// Sets the value of [parent][crate::model::CreateClusterRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::CreateClusterRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = CreateClusterRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    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 [cluster_id][crate::model::CreateClusterRequest::cluster_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::CreateClusterRequest;
    /// let x = CreateClusterRequest::new().set_cluster_id("example");
    /// ```
    pub fn set_cluster_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.cluster_id = v.into();
        self
    }

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

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

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

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

/// Request message for
/// [UpdateCluster][google.cloud.hypercomputecluster.v1.HypercomputeCluster.UpdateCluster].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.UpdateCluster]: crate::client::HypercomputeCluster::update_cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateClusterRequest {
    /// Required. Cluster to update.
    pub cluster: std::option::Option<crate::model::Cluster>,

    /// Optional. Mask specifying which fields in the cluster to update. All paths
    /// must be specified explicitly - wildcards are not supported. At least one
    /// path must be provided.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    pub request_id: std::string::String,

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

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

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

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

    /// Sets the value of [update_mask][crate::model::UpdateClusterRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::UpdateClusterRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateClusterRequest::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::UpdateClusterRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::UpdateClusterRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateClusterRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateClusterRequest::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
    }

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

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

/// Request message for
/// [DeleteCluster][google.cloud.hypercomputecluster.v1.HypercomputeCluster.DeleteCluster].
///
/// [google.cloud.hypercomputecluster.v1.HypercomputeCluster.DeleteCluster]: crate::client::HypercomputeCluster::delete_cluster
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteClusterRequest {
    /// Required. Name of the cluster to delete, in the format
    /// `projects/{project}/locations/{location}/clusters/{cluster}`.
    pub name: std::string::String,

    /// Optional. A unique identifier for this request. A random UUID is
    /// recommended. This request is idempotent if and only if `request_id` is
    /// provided.
    pub request_id: std::string::String,

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

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

    /// Sets the value of [name][crate::model::DeleteClusterRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::DeleteClusterRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let cluster_id = "cluster_id";
    /// let x = DeleteClusterRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/clusters/{cluster_id}"));
    /// ```
    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 [request_id][crate::model::DeleteClusterRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::DeleteClusterRequest;
    /// let x = DeleteClusterRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

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

/// A resource representing a network that connects the various components of a
/// cluster together.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkResource {
    /// Immutable. Configuration for this network resource, which describes how it
    /// should be created or imported. This field only controls how the network
    /// resource is initially created or imported. Subsequent changes to the
    /// network resource should be made via the resource's API and will not be
    /// reflected in the configuration.
    pub config: std::option::Option<crate::model::NetworkResourceConfig>,

    /// Reference to the network resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of network resource.
    pub reference: std::option::Option<crate::model::network_resource::Reference>,

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

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

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

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

    /// Sets the value of [reference][crate::model::NetworkResource::reference].
    ///
    /// Note that all the setters affecting `reference` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NetworkResource;
    /// use google_cloud_hypercomputecluster_v1::model::NetworkReference;
    /// let x = NetworkResource::new().set_reference(Some(
    ///     google_cloud_hypercomputecluster_v1::model::network_resource::Reference::Network(NetworkReference::default().into())));
    /// ```
    pub fn set_reference<
        T: std::convert::Into<std::option::Option<crate::model::network_resource::Reference>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.reference = v.into();
        self
    }

    /// The value of [reference][crate::model::NetworkResource::reference]
    /// if it holds a `Network`, `None` if the field is not set or
    /// holds a different branch.
    pub fn network(&self) -> std::option::Option<&std::boxed::Box<crate::model::NetworkReference>> {
        #[allow(unreachable_patterns)]
        self.reference.as_ref().and_then(|v| match v {
            crate::model::network_resource::Reference::Network(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [reference][crate::model::NetworkResource::reference]
    /// to hold a `Network`.
    ///
    /// Note that all the setters affecting `reference` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NetworkResource;
    /// use google_cloud_hypercomputecluster_v1::model::NetworkReference;
    /// let x = NetworkResource::new().set_network(NetworkReference::default()/* use setters */);
    /// assert!(x.network().is_some());
    /// ```
    pub fn set_network<T: std::convert::Into<std::boxed::Box<crate::model::NetworkReference>>>(
        mut self,
        v: T,
    ) -> Self {
        self.reference =
            std::option::Option::Some(crate::model::network_resource::Reference::Network(v.into()));
        self
    }
}

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

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

    /// Reference to the network resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of network resource.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Reference {
        /// Reference to a network in Google Compute Engine.
        Network(std::boxed::Box<crate::model::NetworkReference>),
    }
}

/// A reference to a [VPC network](https://cloud.google.com/vpc/docs/vpc) in
/// Google Compute Engine.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkReference {
    /// Output only. Name of the network, in the format
    /// `projects/{project}/global/networks/{network}`.
    pub network: std::string::String,

    /// Output only. Name of the particular subnetwork being used by the cluster,
    /// in the format
    /// `projects/{project}/regions/{region}/subnetworks/{subnetwork}`.
    pub subnetwork: std::string::String,

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

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

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

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

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

/// Describes how a network resource should be initialized. Each network resource
/// can either be imported from an existing Google Cloud resource or initialized
/// when the cluster is created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NetworkResourceConfig {
    /// Particular type of configuration for this network resource.
    pub config: std::option::Option<crate::model::network_resource_config::Config>,

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

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

    /// Sets the value of [config][crate::model::NetworkResourceConfig::config].
    ///
    /// Note that all the setters affecting `config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NetworkResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewNetworkConfig;
    /// let x = NetworkResourceConfig::new().set_config(Some(
    ///     google_cloud_hypercomputecluster_v1::model::network_resource_config::Config::NewNetwork(NewNetworkConfig::default().into())));
    /// ```
    pub fn set_config<
        T: std::convert::Into<std::option::Option<crate::model::network_resource_config::Config>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = v.into();
        self
    }

    /// The value of [config][crate::model::NetworkResourceConfig::config]
    /// if it holds a `NewNetwork`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_network(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewNetworkConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::network_resource_config::Config::NewNetwork(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::NetworkResourceConfig::config]
    /// to hold a `NewNetwork`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NetworkResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewNetworkConfig;
    /// let x = NetworkResourceConfig::new().set_new_network(NewNetworkConfig::default()/* use setters */);
    /// assert!(x.new_network().is_some());
    /// assert!(x.existing_network().is_none());
    /// ```
    pub fn set_new_network<
        T: std::convert::Into<std::boxed::Box<crate::model::NewNetworkConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::network_resource_config::Config::NewNetwork(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::NetworkResourceConfig::config]
    /// if it holds a `ExistingNetwork`, `None` if the field is not set or
    /// holds a different branch.
    pub fn existing_network(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ExistingNetworkConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::network_resource_config::Config::ExistingNetwork(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::NetworkResourceConfig::config]
    /// to hold a `ExistingNetwork`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NetworkResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::ExistingNetworkConfig;
    /// let x = NetworkResourceConfig::new().set_existing_network(ExistingNetworkConfig::default()/* use setters */);
    /// assert!(x.existing_network().is_some());
    /// assert!(x.new_network().is_none());
    /// ```
    pub fn set_existing_network<
        T: std::convert::Into<std::boxed::Box<crate::model::ExistingNetworkConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::network_resource_config::Config::ExistingNetwork(v.into()),
        );
        self
    }
}

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

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

    /// Particular type of configuration for this network resource.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that a new network should be
        /// created.
        NewNetwork(std::boxed::Box<crate::model::NewNetworkConfig>),
        /// Optional. Immutable. If set, indicates that an existing network should be
        /// imported.
        ExistingNetwork(std::boxed::Box<crate::model::ExistingNetworkConfig>),
    }
}

/// When set in a
/// [NetworkResourceConfig][google.cloud.hypercomputecluster.v1.NetworkResourceConfig],
/// indicates that a new network should be created.
///
/// [google.cloud.hypercomputecluster.v1.NetworkResourceConfig]: crate::model::NetworkResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewNetworkConfig {
    /// Required. Immutable. Name of the network to create, in the format
    /// `projects/{project}/global/networks/{network}`.
    pub network: std::string::String,

    /// Optional. Immutable. Description of the network. Maximum of 2048
    /// characters.
    pub description: std::string::String,

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

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

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

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

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

/// When set in a
/// [NetworkResourceConfig][google.cloud.hypercomputecluster.v1.NetworkResourceConfig],
/// indicates that an existing network should be imported.
///
/// [google.cloud.hypercomputecluster.v1.NetworkResourceConfig]: crate::model::NetworkResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExistingNetworkConfig {
    /// Required. Immutable. Name of the network to import, in the format
    /// `projects/{project}/global/networks/{network}`.
    pub network: std::string::String,

    /// Required. Immutable. Particular subnetwork to use, in the format
    /// `projects/{project}/regions/{region}/subnetworks/{subnetwork}`.
    pub subnetwork: std::string::String,

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

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

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

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

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

/// A resource representing a form of persistent storage that is accessible to
/// compute resources in the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StorageResource {
    /// Required. Immutable. Configuration for this storage resource, which
    /// describes how it should be created or imported. This field only controls
    /// how the storage resource is initially created or imported. Subsequent
    /// changes to the storage resource should be made via the resource's API and
    /// will not be reflected in the configuration.
    pub config: std::option::Option<crate::model::StorageResourceConfig>,

    /// Reference to the storage resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of storage resource.
    pub reference: std::option::Option<crate::model::storage_resource::Reference>,

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

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

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

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

    /// Sets the value of [reference][crate::model::StorageResource::reference].
    ///
    /// Note that all the setters affecting `reference` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResource;
    /// use google_cloud_hypercomputecluster_v1::model::FilestoreReference;
    /// let x = StorageResource::new().set_reference(Some(
    ///     google_cloud_hypercomputecluster_v1::model::storage_resource::Reference::Filestore(FilestoreReference::default().into())));
    /// ```
    pub fn set_reference<
        T: std::convert::Into<std::option::Option<crate::model::storage_resource::Reference>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.reference = v.into();
        self
    }

    /// The value of [reference][crate::model::StorageResource::reference]
    /// if it holds a `Filestore`, `None` if the field is not set or
    /// holds a different branch.
    pub fn filestore(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::FilestoreReference>> {
        #[allow(unreachable_patterns)]
        self.reference.as_ref().and_then(|v| match v {
            crate::model::storage_resource::Reference::Filestore(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [reference][crate::model::StorageResource::reference]
    /// to hold a `Filestore`.
    ///
    /// Note that all the setters affecting `reference` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResource;
    /// use google_cloud_hypercomputecluster_v1::model::FilestoreReference;
    /// let x = StorageResource::new().set_filestore(FilestoreReference::default()/* use setters */);
    /// assert!(x.filestore().is_some());
    /// assert!(x.bucket().is_none());
    /// assert!(x.lustre().is_none());
    /// ```
    pub fn set_filestore<
        T: std::convert::Into<std::boxed::Box<crate::model::FilestoreReference>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.reference = std::option::Option::Some(
            crate::model::storage_resource::Reference::Filestore(v.into()),
        );
        self
    }

    /// The value of [reference][crate::model::StorageResource::reference]
    /// if it holds a `Bucket`, `None` if the field is not set or
    /// holds a different branch.
    pub fn bucket(&self) -> std::option::Option<&std::boxed::Box<crate::model::BucketReference>> {
        #[allow(unreachable_patterns)]
        self.reference.as_ref().and_then(|v| match v {
            crate::model::storage_resource::Reference::Bucket(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [reference][crate::model::StorageResource::reference]
    /// to hold a `Bucket`.
    ///
    /// Note that all the setters affecting `reference` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResource;
    /// use google_cloud_hypercomputecluster_v1::model::BucketReference;
    /// let x = StorageResource::new().set_bucket(BucketReference::default()/* use setters */);
    /// assert!(x.bucket().is_some());
    /// assert!(x.filestore().is_none());
    /// assert!(x.lustre().is_none());
    /// ```
    pub fn set_bucket<T: std::convert::Into<std::boxed::Box<crate::model::BucketReference>>>(
        mut self,
        v: T,
    ) -> Self {
        self.reference =
            std::option::Option::Some(crate::model::storage_resource::Reference::Bucket(v.into()));
        self
    }

    /// The value of [reference][crate::model::StorageResource::reference]
    /// if it holds a `Lustre`, `None` if the field is not set or
    /// holds a different branch.
    pub fn lustre(&self) -> std::option::Option<&std::boxed::Box<crate::model::LustreReference>> {
        #[allow(unreachable_patterns)]
        self.reference.as_ref().and_then(|v| match v {
            crate::model::storage_resource::Reference::Lustre(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [reference][crate::model::StorageResource::reference]
    /// to hold a `Lustre`.
    ///
    /// Note that all the setters affecting `reference` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResource;
    /// use google_cloud_hypercomputecluster_v1::model::LustreReference;
    /// let x = StorageResource::new().set_lustre(LustreReference::default()/* use setters */);
    /// assert!(x.lustre().is_some());
    /// assert!(x.filestore().is_none());
    /// assert!(x.bucket().is_none());
    /// ```
    pub fn set_lustre<T: std::convert::Into<std::boxed::Box<crate::model::LustreReference>>>(
        mut self,
        v: T,
    ) -> Self {
        self.reference =
            std::option::Option::Some(crate::model::storage_resource::Reference::Lustre(v.into()));
        self
    }
}

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

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

    /// Reference to the storage resource in Google Cloud. Exactly one of these
    /// fields will be populated based on the configured type of storage resource.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Reference {
        /// Reference to a Filestore instance. Populated if and only if the storage
        /// resource was configured to use Filestore.
        Filestore(std::boxed::Box<crate::model::FilestoreReference>),
        /// Reference to a Google Cloud Storage bucket. Populated if and only if the
        /// storage resource was configured to use Google Cloud Storage.
        Bucket(std::boxed::Box<crate::model::BucketReference>),
        /// Reference to a Managed Lustre instance. Populated if and only if the
        /// storage resource was configured to use Managed Lustre.
        Lustre(std::boxed::Box<crate::model::LustreReference>),
    }
}

/// A reference to a [Filestore](https://cloud.google.com/filestore) instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FilestoreReference {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub filestore: std::string::String,

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

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

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

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

/// A reference to a [Google Cloud Storage](https://cloud.google.com/storage)
/// bucket.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BucketReference {
    /// Output only. Name of the bucket.
    pub bucket: std::string::String,

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

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

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

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

/// A reference to a [Managed
/// Lustre](https://cloud.google.com/products/managed-lustre) instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct LustreReference {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub lustre: std::string::String,

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

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

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

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

/// Describes how a storage resource should be initialized. Each storage resource
/// can either be imported from an existing Google Cloud resource or initialized
/// when the cluster is created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StorageResourceConfig {
    /// Particular type of configuration for this storage resource.
    pub config: std::option::Option<crate::model::storage_resource_config::Config>,

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

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

    /// Sets the value of [config][crate::model::StorageResourceConfig::config].
    ///
    /// Note that all the setters affecting `config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewFilestoreConfig;
    /// let x = StorageResourceConfig::new().set_config(Some(
    ///     google_cloud_hypercomputecluster_v1::model::storage_resource_config::Config::NewFilestore(NewFilestoreConfig::default().into())));
    /// ```
    pub fn set_config<
        T: std::convert::Into<std::option::Option<crate::model::storage_resource_config::Config>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = v.into();
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `NewFilestore`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_filestore(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewFilestoreConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::NewFilestore(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `NewFilestore`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewFilestoreConfig;
    /// let x = StorageResourceConfig::new().set_new_filestore(NewFilestoreConfig::default()/* use setters */);
    /// assert!(x.new_filestore().is_some());
    /// assert!(x.existing_filestore().is_none());
    /// assert!(x.new_bucket().is_none());
    /// assert!(x.existing_bucket().is_none());
    /// assert!(x.new_lustre().is_none());
    /// assert!(x.existing_lustre().is_none());
    /// ```
    pub fn set_new_filestore<
        T: std::convert::Into<std::boxed::Box<crate::model::NewFilestoreConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::NewFilestore(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `ExistingFilestore`, `None` if the field is not set or
    /// holds a different branch.
    pub fn existing_filestore(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ExistingFilestoreConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::ExistingFilestore(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `ExistingFilestore`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::ExistingFilestoreConfig;
    /// let x = StorageResourceConfig::new().set_existing_filestore(ExistingFilestoreConfig::default()/* use setters */);
    /// assert!(x.existing_filestore().is_some());
    /// assert!(x.new_filestore().is_none());
    /// assert!(x.new_bucket().is_none());
    /// assert!(x.existing_bucket().is_none());
    /// assert!(x.new_lustre().is_none());
    /// assert!(x.existing_lustre().is_none());
    /// ```
    pub fn set_existing_filestore<
        T: std::convert::Into<std::boxed::Box<crate::model::ExistingFilestoreConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::ExistingFilestore(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `NewBucket`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_bucket(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewBucketConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::NewBucket(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `NewBucket`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewBucketConfig;
    /// let x = StorageResourceConfig::new().set_new_bucket(NewBucketConfig::default()/* use setters */);
    /// assert!(x.new_bucket().is_some());
    /// assert!(x.new_filestore().is_none());
    /// assert!(x.existing_filestore().is_none());
    /// assert!(x.existing_bucket().is_none());
    /// assert!(x.new_lustre().is_none());
    /// assert!(x.existing_lustre().is_none());
    /// ```
    pub fn set_new_bucket<T: std::convert::Into<std::boxed::Box<crate::model::NewBucketConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::NewBucket(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `ExistingBucket`, `None` if the field is not set or
    /// holds a different branch.
    pub fn existing_bucket(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ExistingBucketConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::ExistingBucket(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `ExistingBucket`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::ExistingBucketConfig;
    /// let x = StorageResourceConfig::new().set_existing_bucket(ExistingBucketConfig::default()/* use setters */);
    /// assert!(x.existing_bucket().is_some());
    /// assert!(x.new_filestore().is_none());
    /// assert!(x.existing_filestore().is_none());
    /// assert!(x.new_bucket().is_none());
    /// assert!(x.new_lustre().is_none());
    /// assert!(x.existing_lustre().is_none());
    /// ```
    pub fn set_existing_bucket<
        T: std::convert::Into<std::boxed::Box<crate::model::ExistingBucketConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::ExistingBucket(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `NewLustre`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_lustre(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewLustreConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::NewLustre(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `NewLustre`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewLustreConfig;
    /// let x = StorageResourceConfig::new().set_new_lustre(NewLustreConfig::default()/* use setters */);
    /// assert!(x.new_lustre().is_some());
    /// assert!(x.new_filestore().is_none());
    /// assert!(x.existing_filestore().is_none());
    /// assert!(x.new_bucket().is_none());
    /// assert!(x.existing_bucket().is_none());
    /// assert!(x.existing_lustre().is_none());
    /// ```
    pub fn set_new_lustre<T: std::convert::Into<std::boxed::Box<crate::model::NewLustreConfig>>>(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::NewLustre(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::StorageResourceConfig::config]
    /// if it holds a `ExistingLustre`, `None` if the field is not set or
    /// holds a different branch.
    pub fn existing_lustre(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ExistingLustreConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::storage_resource_config::Config::ExistingLustre(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::StorageResourceConfig::config]
    /// to hold a `ExistingLustre`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::StorageResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::ExistingLustreConfig;
    /// let x = StorageResourceConfig::new().set_existing_lustre(ExistingLustreConfig::default()/* use setters */);
    /// assert!(x.existing_lustre().is_some());
    /// assert!(x.new_filestore().is_none());
    /// assert!(x.existing_filestore().is_none());
    /// assert!(x.new_bucket().is_none());
    /// assert!(x.existing_bucket().is_none());
    /// assert!(x.new_lustre().is_none());
    /// ```
    pub fn set_existing_lustre<
        T: std::convert::Into<std::boxed::Box<crate::model::ExistingLustreConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::storage_resource_config::Config::ExistingLustre(v.into()),
        );
        self
    }
}

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

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

    /// Particular type of configuration for this storage resource.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that a new Filestore instance
        /// should be created.
        NewFilestore(std::boxed::Box<crate::model::NewFilestoreConfig>),
        /// Optional. Immutable. If set, indicates that an existing Filestore
        /// instance should be imported.
        ExistingFilestore(std::boxed::Box<crate::model::ExistingFilestoreConfig>),
        /// Optional. Immutable. If set, indicates that a new Cloud Storage bucket
        /// should be created.
        NewBucket(std::boxed::Box<crate::model::NewBucketConfig>),
        /// Optional. Immutable. If set, indicates that an existing Cloud Storage
        /// bucket should be imported.
        ExistingBucket(std::boxed::Box<crate::model::ExistingBucketConfig>),
        /// Optional. Immutable. If set, indicates that a new Managed Lustre instance
        /// should be created.
        NewLustre(std::boxed::Box<crate::model::NewLustreConfig>),
        /// Optional. Immutable. If set, indicates that an existing Managed Lustre
        /// instance should be imported.
        ExistingLustre(std::boxed::Box<crate::model::ExistingLustreConfig>),
    }
}

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that a new [Filestore](https://cloud.google.com/filestore) instance
/// should be created.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewFilestoreConfig {
    /// Required. Immutable. Name of the Filestore instance to create, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    pub filestore: std::string::String,

    /// Optional. Immutable. Description of the instance. Maximum of 2048
    /// characters.
    pub description: std::string::String,

    /// Required. Immutable. File system shares on the instance. Exactly one file
    /// share must be specified.
    pub file_shares: std::vec::Vec<crate::model::FileShareConfig>,

    /// Required. Immutable. Service tier to use for the instance.
    pub tier: crate::model::new_filestore_config::Tier,

    /// Optional. Immutable. Access protocol to use for all file shares in the
    /// instance. Defaults to NFS V3 if not set.
    pub protocol: crate::model::new_filestore_config::Protocol,

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

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

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

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

    /// Sets the value of [tier][crate::model::NewFilestoreConfig::tier].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewFilestoreConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_filestore_config::Tier;
    /// let x0 = NewFilestoreConfig::new().set_tier(Tier::Zonal);
    /// let x1 = NewFilestoreConfig::new().set_tier(Tier::Regional);
    /// ```
    pub fn set_tier<T: std::convert::Into<crate::model::new_filestore_config::Tier>>(
        mut self,
        v: T,
    ) -> Self {
        self.tier = v.into();
        self
    }

    /// Sets the value of [protocol][crate::model::NewFilestoreConfig::protocol].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewFilestoreConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_filestore_config::Protocol;
    /// let x0 = NewFilestoreConfig::new().set_protocol(Protocol::Nfsv3);
    /// let x1 = NewFilestoreConfig::new().set_protocol(Protocol::Nfsv41);
    /// ```
    pub fn set_protocol<T: std::convert::Into<crate::model::new_filestore_config::Protocol>>(
        mut self,
        v: T,
    ) -> Self {
        self.protocol = v.into();
        self
    }
}

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

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

    /// Available [service
    /// tiers](https://cloud.google.com/filestore/docs/service-tiers) for Filestore
    /// instances.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Tier {
        /// Not set.
        Unspecified,
        /// Offers expanded capacity and performance scaling capabilities suitable
        /// for high-performance computing application requirements.
        Zonal,
        /// Offers features and availability needed for mission-critical,
        /// high-performance computing workloads.
        Regional,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [Tier::value] or
        /// [Tier::name].
        UnknownValue(tier::UnknownValue),
    }

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

    impl Tier {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Zonal => std::option::Option::Some(4),
                Self::Regional => 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("TIER_UNSPECIFIED"),
                Self::Zonal => std::option::Option::Some("ZONAL"),
                Self::Regional => std::option::Option::Some("REGIONAL"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

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

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

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

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

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

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

    impl Protocol {
        /// 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::Nfsv3 => std::option::Option::Some(1),
                Self::Nfsv41 => 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("PROTOCOL_UNSPECIFIED"),
                Self::Nfsv3 => std::option::Option::Some("NFSV3"),
                Self::Nfsv41 => std::option::Option::Some("NFSV41"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for Protocol {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "PROTOCOL_UNSPECIFIED" => Self::Unspecified,
                "NFSV3" => Self::Nfsv3,
                "NFSV41" => Self::Nfsv41,
                _ => Self::UnknownValue(protocol::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// Message describing filestore configuration
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct FileShareConfig {
    /// Required. Size of the filestore in GB. Must be between 1024 and 102400, and
    /// must meet scalability requirements described at
    /// <https://cloud.google.com/filestore/docs/service-tiers>.
    pub capacity_gb: i64,

    /// Required. Filestore share location
    pub file_share: std::string::String,

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

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

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

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

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

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that an existing [Filestore](https://cloud.google.com/filestore)
/// instance should be imported.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExistingFilestoreConfig {
    /// Required. Immutable. Name of the Filestore instance to import, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    pub filestore: std::string::String,

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

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

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

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

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that a new [Google Cloud Storage](https://cloud.google.com/storage)
/// bucket should be created.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewBucketConfig {
    /// Required. Immutable. Name of the Cloud Storage bucket to create.
    pub bucket: std::string::String,

    /// Optional. Immutable. If set, indicates that the bucket should use
    /// [hierarchical
    /// namespaces](https://cloud.google.com/storage/docs/hns-overview).
    pub hierarchical_namespace: std::option::Option<crate::model::GcsHierarchicalNamespaceConfig>,

    /// Storage class of the bucket, which can be set automatically or explicitly.
    pub option: std::option::Option<crate::model::new_bucket_config::Option>,

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

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

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

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

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

    /// Sets the value of [option][crate::model::NewBucketConfig::option].
    ///
    /// Note that all the setters affecting `option` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewBucketConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_bucket_config::StorageClass;
    /// let x0 = NewBucketConfig::new().set_option(Some(
    ///     google_cloud_hypercomputecluster_v1::model::new_bucket_config::Option::StorageClass(StorageClass::Standard)));
    /// let x1 = NewBucketConfig::new().set_option(Some(
    ///     google_cloud_hypercomputecluster_v1::model::new_bucket_config::Option::StorageClass(StorageClass::Nearline)));
    /// let x2 = NewBucketConfig::new().set_option(Some(
    ///     google_cloud_hypercomputecluster_v1::model::new_bucket_config::Option::StorageClass(StorageClass::Coldline)));
    /// ```
    pub fn set_option<
        T: std::convert::Into<std::option::Option<crate::model::new_bucket_config::Option>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.option = v.into();
        self
    }

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

    /// Sets the value of [option][crate::model::NewBucketConfig::option]
    /// to hold a `Autoclass`.
    ///
    /// Note that all the setters affecting `option` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewBucketConfig;
    /// use google_cloud_hypercomputecluster_v1::model::GcsAutoclassConfig;
    /// let x = NewBucketConfig::new().set_autoclass(GcsAutoclassConfig::default()/* use setters */);
    /// assert!(x.autoclass().is_some());
    /// assert!(x.storage_class().is_none());
    /// ```
    pub fn set_autoclass<
        T: std::convert::Into<std::boxed::Box<crate::model::GcsAutoclassConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.option =
            std::option::Option::Some(crate::model::new_bucket_config::Option::Autoclass(v.into()));
        self
    }

    /// The value of [option][crate::model::NewBucketConfig::option]
    /// if it holds a `StorageClass`, `None` if the field is not set or
    /// holds a different branch.
    pub fn storage_class(
        &self,
    ) -> std::option::Option<&crate::model::new_bucket_config::StorageClass> {
        #[allow(unreachable_patterns)]
        self.option.as_ref().and_then(|v| match v {
            crate::model::new_bucket_config::Option::StorageClass(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [option][crate::model::NewBucketConfig::option]
    /// to hold a `StorageClass`.
    ///
    /// Note that all the setters affecting `option` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewBucketConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_bucket_config::StorageClass;
    /// let x0 = NewBucketConfig::new().set_storage_class(StorageClass::Standard);
    /// let x1 = NewBucketConfig::new().set_storage_class(StorageClass::Nearline);
    /// let x2 = NewBucketConfig::new().set_storage_class(StorageClass::Coldline);
    /// assert!(x0.storage_class().is_some());
    /// assert!(x0.autoclass().is_none());
    /// assert!(x1.storage_class().is_some());
    /// assert!(x1.autoclass().is_none());
    /// assert!(x2.storage_class().is_some());
    /// assert!(x2.autoclass().is_none());
    /// ```
    pub fn set_storage_class<
        T: std::convert::Into<crate::model::new_bucket_config::StorageClass>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.option = std::option::Option::Some(
            crate::model::new_bucket_config::Option::StorageClass(v.into()),
        );
        self
    }
}

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

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

    /// [Storage class](https://cloud.google.com/storage/docs/storage-classes) for
    /// a Cloud Storage bucket.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum StorageClass {
        /// Not set.
        Unspecified,
        /// Best for data that is frequently accessed.
        Standard,
        /// Low-cost storage for data that is accessed less frequently.
        Nearline,
        /// Very low-cost storage for infrequently accessed data.
        Coldline,
        /// Lowest-cost storage for data archiving, online backup, and disaster
        /// recovery.
        Archive,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [StorageClass::value] or
        /// [StorageClass::name].
        UnknownValue(storage_class::UnknownValue),
    }

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

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

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

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

    impl std::fmt::Display for StorageClass {
        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 StorageClass {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Standard,
                2 => Self::Nearline,
                3 => Self::Coldline,
                4 => Self::Archive,
                _ => Self::UnknownValue(storage_class::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for StorageClass {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STORAGE_CLASS_UNSPECIFIED" => Self::Unspecified,
                "STANDARD" => Self::Standard,
                "NEARLINE" => Self::Nearline,
                "COLDLINE" => Self::Coldline,
                "ARCHIVE" => Self::Archive,
                _ => Self::UnknownValue(storage_class::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

    /// Storage class of the bucket, which can be set automatically or explicitly.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Option {
        /// Optional. Immutable. If set, indicates that the bucket should use
        /// [Autoclass](https://cloud.google.com/storage/docs/autoclass).
        Autoclass(std::boxed::Box<crate::model::GcsAutoclassConfig>),
        /// Optional. Immutable. If set, uses the provided storage class as the
        /// bucket's default storage class.
        StorageClass(crate::model::new_bucket_config::StorageClass),
    }
}

/// Message describing Google Cloud Storage autoclass configuration
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcsAutoclassConfig {
    /// Required. Enables Auto-class feature.
    pub enabled: bool,

    /// Optional. Terminal storage class of the autoclass bucket
    pub terminal_storage_class: crate::model::gcs_autoclass_config::TerminalStorageClass,

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

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

    /// Sets the value of [enabled][crate::model::GcsAutoclassConfig::enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::GcsAutoclassConfig;
    /// let x = GcsAutoclassConfig::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 [terminal_storage_class][crate::model::GcsAutoclassConfig::terminal_storage_class].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::GcsAutoclassConfig;
    /// use google_cloud_hypercomputecluster_v1::model::gcs_autoclass_config::TerminalStorageClass;
    /// let x0 = GcsAutoclassConfig::new().set_terminal_storage_class(TerminalStorageClass::Unspecified);
    /// ```
    pub fn set_terminal_storage_class<
        T: std::convert::Into<crate::model::gcs_autoclass_config::TerminalStorageClass>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.terminal_storage_class = v.into();
        self
    }
}

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

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

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

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

    impl TerminalStorageClass {
        /// 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::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("TERMINAL_STORAGE_CLASS_UNSPECIFIED")
                }
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

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

    impl serde::ser::Serialize for TerminalStorageClass {
        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::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

/// Message describing Google Cloud Storage hierarchical namespace configuration
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct GcsHierarchicalNamespaceConfig {
    /// Required. Enables hierarchical namespace setup for the bucket.
    pub enabled: bool,

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

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

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

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that an existing [Google Cloud
/// Storage](https://cloud.google.com/storage) bucket should be imported.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExistingBucketConfig {
    /// Required. Immutable. Name of the Cloud Storage bucket to import.
    pub bucket: std::string::String,

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

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

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

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

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that a new [Managed
/// Lustre](https://cloud.google.com/products/managed-lustre) instance should be
/// created.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewLustreConfig {
    /// Required. Immutable. Name of the Managed Lustre instance to create, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    pub lustre: std::string::String,

    /// Optional. Immutable. Description of the Managed Lustre instance. Maximum of
    /// 2048 characters.
    pub description: std::string::String,

    /// Required. Immutable. Filesystem name for this instance. This name is used
    /// by client-side tools, including when mounting the instance. Must be 8
    /// characters or less and can only contain letters and numbers.
    pub filesystem: std::string::String,

    /// Required. Immutable. Storage capacity of the instance in gibibytes (GiB).
    /// Allowed values are between 18000 and 7632000.
    pub capacity_gb: i64,

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

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

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

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

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

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

/// When set in a
/// [StorageResourceConfig][google.cloud.hypercomputecluster.v1.StorageResourceConfig],
/// indicates that an existing [Managed
/// Lustre](https://cloud.google.com/products/managed-lustre) instance should be
/// imported.
///
/// [google.cloud.hypercomputecluster.v1.StorageResourceConfig]: crate::model::StorageResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ExistingLustreConfig {
    /// Required. Immutable. Name of the Managed Lustre instance to import, in the
    /// format `projects/{project}/locations/{location}/instances/{instance}`
    pub lustre: std::string::String,

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

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

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

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

/// A resource defining how virtual machines and accelerators should be
/// provisioned for the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeResource {
    /// Required. Immutable. Configuration for this compute resource, which
    /// describes how it should be created at runtime.
    pub config: std::option::Option<crate::model::ComputeResourceConfig>,

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

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

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

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

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

/// Describes how a compute resource should be created at runtime.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeResourceConfig {
    /// Particular type of configuration for this compute resource.
    pub config: std::option::Option<crate::model::compute_resource_config::Config>,

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

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

    /// Sets the value of [config][crate::model::ComputeResourceConfig::config].
    ///
    /// Note that all the setters affecting `config` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ComputeResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewOnDemandInstancesConfig;
    /// let x = ComputeResourceConfig::new().set_config(Some(
    ///     google_cloud_hypercomputecluster_v1::model::compute_resource_config::Config::NewOnDemandInstances(NewOnDemandInstancesConfig::default().into())));
    /// ```
    pub fn set_config<
        T: std::convert::Into<std::option::Option<crate::model::compute_resource_config::Config>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = v.into();
        self
    }

    /// The value of [config][crate::model::ComputeResourceConfig::config]
    /// if it holds a `NewOnDemandInstances`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_on_demand_instances(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewOnDemandInstancesConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::compute_resource_config::Config::NewOnDemandInstances(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::ComputeResourceConfig::config]
    /// to hold a `NewOnDemandInstances`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ComputeResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewOnDemandInstancesConfig;
    /// let x = ComputeResourceConfig::new().set_new_on_demand_instances(NewOnDemandInstancesConfig::default()/* use setters */);
    /// assert!(x.new_on_demand_instances().is_some());
    /// assert!(x.new_spot_instances().is_none());
    /// assert!(x.new_reserved_instances().is_none());
    /// assert!(x.new_flex_start_instances().is_none());
    /// ```
    pub fn set_new_on_demand_instances<
        T: std::convert::Into<std::boxed::Box<crate::model::NewOnDemandInstancesConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::compute_resource_config::Config::NewOnDemandInstances(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::ComputeResourceConfig::config]
    /// if it holds a `NewSpotInstances`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_spot_instances(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewSpotInstancesConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::compute_resource_config::Config::NewSpotInstances(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::ComputeResourceConfig::config]
    /// to hold a `NewSpotInstances`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ComputeResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewSpotInstancesConfig;
    /// let x = ComputeResourceConfig::new().set_new_spot_instances(NewSpotInstancesConfig::default()/* use setters */);
    /// assert!(x.new_spot_instances().is_some());
    /// assert!(x.new_on_demand_instances().is_none());
    /// assert!(x.new_reserved_instances().is_none());
    /// assert!(x.new_flex_start_instances().is_none());
    /// ```
    pub fn set_new_spot_instances<
        T: std::convert::Into<std::boxed::Box<crate::model::NewSpotInstancesConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::compute_resource_config::Config::NewSpotInstances(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::ComputeResourceConfig::config]
    /// if it holds a `NewReservedInstances`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_reserved_instances(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewReservedInstancesConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::compute_resource_config::Config::NewReservedInstances(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::ComputeResourceConfig::config]
    /// to hold a `NewReservedInstances`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ComputeResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewReservedInstancesConfig;
    /// let x = ComputeResourceConfig::new().set_new_reserved_instances(NewReservedInstancesConfig::default()/* use setters */);
    /// assert!(x.new_reserved_instances().is_some());
    /// assert!(x.new_on_demand_instances().is_none());
    /// assert!(x.new_spot_instances().is_none());
    /// assert!(x.new_flex_start_instances().is_none());
    /// ```
    pub fn set_new_reserved_instances<
        T: std::convert::Into<std::boxed::Box<crate::model::NewReservedInstancesConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::compute_resource_config::Config::NewReservedInstances(v.into()),
        );
        self
    }

    /// The value of [config][crate::model::ComputeResourceConfig::config]
    /// if it holds a `NewFlexStartInstances`, `None` if the field is not set or
    /// holds a different branch.
    pub fn new_flex_start_instances(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::NewFlexStartInstancesConfig>> {
        #[allow(unreachable_patterns)]
        self.config.as_ref().and_then(|v| match v {
            crate::model::compute_resource_config::Config::NewFlexStartInstances(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [config][crate::model::ComputeResourceConfig::config]
    /// to hold a `NewFlexStartInstances`.
    ///
    /// Note that all the setters affecting `config` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::ComputeResourceConfig;
    /// use google_cloud_hypercomputecluster_v1::model::NewFlexStartInstancesConfig;
    /// let x = ComputeResourceConfig::new().set_new_flex_start_instances(NewFlexStartInstancesConfig::default()/* use setters */);
    /// assert!(x.new_flex_start_instances().is_some());
    /// assert!(x.new_on_demand_instances().is_none());
    /// assert!(x.new_spot_instances().is_none());
    /// assert!(x.new_reserved_instances().is_none());
    /// ```
    pub fn set_new_flex_start_instances<
        T: std::convert::Into<std::boxed::Box<crate::model::NewFlexStartInstancesConfig>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.config = std::option::Option::Some(
            crate::model::compute_resource_config::Config::NewFlexStartInstances(v.into()),
        );
        self
    }
}

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

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

    /// Particular type of configuration for this compute resource.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Config {
        /// Optional. Immutable. If set, indicates that this resource should use
        /// on-demand VMs.
        NewOnDemandInstances(std::boxed::Box<crate::model::NewOnDemandInstancesConfig>),
        /// Optional. Immutable. If set, indicates that this resource should use spot
        /// VMs.
        NewSpotInstances(std::boxed::Box<crate::model::NewSpotInstancesConfig>),
        /// Optional. Immutable. If set, indicates that this resource should use
        /// reserved VMs.
        NewReservedInstances(std::boxed::Box<crate::model::NewReservedInstancesConfig>),
        /// Optional. Immutable. If set, indicates that this resource should use
        /// flex-start VMs.
        NewFlexStartInstances(std::boxed::Box<crate::model::NewFlexStartInstancesConfig>),
    }
}

/// When set in a
/// [ComputeResourceConfig][google.cloud.hypercomputecluster.v1.ComputeResourceConfig],
/// indicates that on-demand (i.e., using the standard provisioning model) VM
/// instances should be created.
///
/// [google.cloud.hypercomputecluster.v1.ComputeResourceConfig]: crate::model::ComputeResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewOnDemandInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    pub zone: std::string::String,

    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](https://cloud.google.com/compute/docs/machine-resource) to use, e.g.
    /// `n2-standard-2`.
    pub machine_type: std::string::String,

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

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

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

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

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

/// When set in a
/// [ComputeResourceConfig][google.cloud.hypercomputecluster.v1.ComputeResourceConfig],
/// indicates that [spot
/// VM](https://cloud.google.com/compute/docs/instances/spot) instances should be
/// created.
///
/// [google.cloud.hypercomputecluster.v1.ComputeResourceConfig]: crate::model::ComputeResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewSpotInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    pub zone: std::string::String,

    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](https://cloud.google.com/compute/docs/machine-resource) to use, e.g.
    /// `n2-standard-2`.
    pub machine_type: std::string::String,

    /// Optional. Termination action for the instance. If not specified, Compute
    /// Engine sets the termination action to DELETE.
    pub termination_action: crate::model::new_spot_instances_config::TerminationAction,

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

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

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

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

    /// Sets the value of [termination_action][crate::model::NewSpotInstancesConfig::termination_action].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewSpotInstancesConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_spot_instances_config::TerminationAction;
    /// let x0 = NewSpotInstancesConfig::new().set_termination_action(TerminationAction::Stop);
    /// let x1 = NewSpotInstancesConfig::new().set_termination_action(TerminationAction::Delete);
    /// ```
    pub fn set_termination_action<
        T: std::convert::Into<crate::model::new_spot_instances_config::TerminationAction>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.termination_action = v.into();
        self
    }
}

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

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

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

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

    impl TerminationAction {
        /// 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::Stop => std::option::Option::Some(1),
                Self::Delete => 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("TERMINATION_ACTION_UNSPECIFIED"),
                Self::Stop => std::option::Option::Some("STOP"),
                Self::Delete => std::option::Option::Some("DELETE"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

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

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

    impl std::convert::From<&str> for TerminationAction {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "TERMINATION_ACTION_UNSPECIFIED" => Self::Unspecified,
                "STOP" => Self::Stop,
                "DELETE" => Self::Delete,
                _ => Self::UnknownValue(termination_action::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

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

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

/// When set in a
/// [ComputeResourceConfig][google.cloud.hypercomputecluster.v1.ComputeResourceConfig],
/// indicates that VM instances should be created from a
/// [reservation](https://cloud.google.com/compute/docs/instances/reservations-overview).
///
/// [google.cloud.hypercomputecluster.v1.ComputeResourceConfig]: crate::model::ComputeResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewReservedInstancesConfig {
    /// Source of the reservation
    pub source: std::option::Option<crate::model::new_reserved_instances_config::Source>,

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

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

    /// Sets the value of [source][crate::model::NewReservedInstancesConfig::source].
    ///
    /// Note that all the setters affecting `source` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewReservedInstancesConfig;
    /// use google_cloud_hypercomputecluster_v1::model::new_reserved_instances_config::Source;
    /// let x = NewReservedInstancesConfig::new().set_source(Some(Source::Reservation("example".to_string())));
    /// ```
    pub fn set_source<
        T: std::convert::Into<
                std::option::Option<crate::model::new_reserved_instances_config::Source>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.source = v.into();
        self
    }

    /// The value of [source][crate::model::NewReservedInstancesConfig::source]
    /// if it holds a `Reservation`, `None` if the field is not set or
    /// holds a different branch.
    pub fn reservation(&self) -> std::option::Option<&std::string::String> {
        #[allow(unreachable_patterns)]
        self.source.as_ref().and_then(|v| match v {
            crate::model::new_reserved_instances_config::Source::Reservation(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [source][crate::model::NewReservedInstancesConfig::source]
    /// to hold a `Reservation`.
    ///
    /// Note that all the setters affecting `source` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::NewReservedInstancesConfig;
    /// let x = NewReservedInstancesConfig::new().set_reservation("example");
    /// assert!(x.reservation().is_some());
    /// ```
    pub fn set_reservation<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.source = std::option::Option::Some(
            crate::model::new_reserved_instances_config::Source::Reservation(v.into()),
        );
        self
    }
}

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

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

    /// Source of the reservation
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Source {
        /// Optional. Immutable. Name of the reservation from which VM instances
        /// should be created, in the format
        /// `projects/{project}/zones/{zone}/reservations/{reservation}`.
        Reservation(std::string::String),
    }
}

/// When set in a
/// [ComputeResourceConfig][google.cloud.hypercomputecluster.v1.ComputeResourceConfig],
/// indicates that VM instances should be created using [Flex
/// Start](https://cloud.google.com/compute/docs/instances/provisioning-models).
///
/// [google.cloud.hypercomputecluster.v1.ComputeResourceConfig]: crate::model::ComputeResourceConfig
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct NewFlexStartInstancesConfig {
    /// Required. Immutable. Name of the zone in which VM instances should run,
    /// e.g., `us-central1-a`. Must be in the same region as the cluster, and must
    /// match the zone of any other resources specified in the cluster.
    pub zone: std::string::String,

    /// Required. Immutable. Name of the Compute Engine [machine
    /// type](https://cloud.google.com/compute/docs/machine-resource) to use, e.g.
    /// `n2-standard-2`.
    pub machine_type: std::string::String,

    /// Required. Immutable. Specifies the time limit for created instances.
    /// Instances will be terminated at the end of this duration.
    pub max_duration: std::option::Option<wkt::Duration>,

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

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

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

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

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

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

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

/// A [Persistent disk](https://cloud.google.com/compute/docs/disks) used as the
/// boot disk for a Compute Engine VM instance.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BootDisk {
    /// Required. Immutable. [Persistent disk
    /// type](https://cloud.google.com/compute/docs/disks#disk-types), in the
    /// format `projects/{project}/zones/{zone}/diskTypes/{disk_type}`.
    pub r#type: std::string::String,

    /// Required. Immutable. Size of the disk in gigabytes. Must be at least 10GB.
    pub size_gb: i64,

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

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

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

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

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

/// The component responsible for scheduling and running workloads on the
/// cluster as well as providing the user interface for interacting with the
/// cluster at runtime.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct Orchestrator {
    /// Particular type of orchestrator to use in this cluster.
    pub option: std::option::Option<crate::model::orchestrator::Option>,

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

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

    /// Sets the value of [option][crate::model::Orchestrator::option].
    ///
    /// Note that all the setters affecting `option` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Orchestrator;
    /// use google_cloud_hypercomputecluster_v1::model::SlurmOrchestrator;
    /// let x = Orchestrator::new().set_option(Some(
    ///     google_cloud_hypercomputecluster_v1::model::orchestrator::Option::Slurm(SlurmOrchestrator::default().into())));
    /// ```
    pub fn set_option<
        T: std::convert::Into<std::option::Option<crate::model::orchestrator::Option>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.option = v.into();
        self
    }

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

    /// Sets the value of [option][crate::model::Orchestrator::option]
    /// to hold a `Slurm`.
    ///
    /// Note that all the setters affecting `option` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::Orchestrator;
    /// use google_cloud_hypercomputecluster_v1::model::SlurmOrchestrator;
    /// let x = Orchestrator::new().set_slurm(SlurmOrchestrator::default()/* use setters */);
    /// assert!(x.slurm().is_some());
    /// ```
    pub fn set_slurm<T: std::convert::Into<std::boxed::Box<crate::model::SlurmOrchestrator>>>(
        mut self,
        v: T,
    ) -> Self {
        self.option =
            std::option::Option::Some(crate::model::orchestrator::Option::Slurm(v.into()));
        self
    }
}

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

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

    /// Particular type of orchestrator to use in this cluster.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Option {
        /// Optional. If set, indicates that the cluster should use Slurm as the
        /// orchestrator.
        Slurm(std::boxed::Box<crate::model::SlurmOrchestrator>),
    }
}

/// When set in [Orchestrator][google.cloud.hypercomputecluster.v1.Orchestrator],
/// indicates that the cluster should use [Slurm](https://slurm.schedmd.com/) as
/// the orchestrator.
///
/// [google.cloud.hypercomputecluster.v1.Orchestrator]: crate::model::Orchestrator
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SlurmOrchestrator {
    /// Required. Configuration for login nodes, which allow users to access the
    /// cluster over SSH.
    pub login_nodes: std::option::Option<crate::model::SlurmLoginNodes>,

    /// Optional. Compute resource configuration for the Slurm nodesets in your
    /// cluster. If not specified, the cluster won't create any nodes.
    pub node_sets: std::vec::Vec<crate::model::SlurmNodeSet>,

    /// Optional. Configuration for the Slurm partitions in your cluster. Each
    /// partition can contain one or more nodesets, and you can submit separate
    /// jobs on each partition. If you don't specify at least one partition in your
    /// cluster, you can't submit jobs to the cluster.
    pub partitions: std::vec::Vec<crate::model::SlurmPartition>,

    /// Optional. Default partition to use for submitted jobs that do not
    /// explicitly specify a partition. Required if and only if there is more than
    /// one partition, in which case it must match the id of one of the partitions.
    pub default_partition: std::string::String,

    /// Optional. Slurm [prolog
    /// scripts](https://slurm.schedmd.com/prolog_epilog.html), which will be
    /// executed by compute nodes before a node begins running a new job. Values
    /// must not be empty.
    pub prolog_bash_scripts: std::vec::Vec<std::string::String>,

    /// Optional. Slurm [epilog
    /// scripts](https://slurm.schedmd.com/prolog_epilog.html), which will be
    /// executed by compute nodes whenever a node finishes running a job. Values
    /// must not be empty.
    pub epilog_bash_scripts: std::vec::Vec<std::string::String>,

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

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

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

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

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

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

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

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

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

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

/// Configuration for Slurm nodesets in the cluster. Nodesets are groups of
/// compute nodes used by Slurm that are responsible for running workloads
/// submitted to the cluster.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SlurmNodeSet {
    /// Required. Identifier for the nodeset, which allows it to be referenced by
    /// partitions. Must conform to
    /// [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034) (lower-case,
    /// alphanumeric, and at most 63 characters).
    pub id: std::string::String,

    /// Optional. ID of the compute resource on which this nodeset will run. Must
    /// match a key in the cluster's
    /// [compute_resources][google.cloud.hypercomputecluster.v1.Cluster.compute_resources].
    ///
    /// [google.cloud.hypercomputecluster.v1.Cluster.compute_resources]: crate::model::Cluster::compute_resources
    pub compute_id: std::string::String,

    /// Optional. How [storage
    /// resources][google.cloud.hypercomputecluster.v1.StorageResource] should be
    /// mounted on each compute node.
    ///
    /// [google.cloud.hypercomputecluster.v1.StorageResource]: crate::model::StorageResource
    pub storage_configs: std::vec::Vec<crate::model::StorageConfig>,

    /// Optional. Number of nodes to be statically created for this nodeset. The
    /// cluster will attempt to ensure that at least this many nodes exist at all
    /// times.
    pub static_node_count: i64,

    /// Optional. Controls how many additional nodes a cluster can bring online to
    /// handle workloads. Set this value to enable dynamic node creation and limit
    /// the number of additional nodes the cluster can bring online. Leave empty if
    /// you do not want the cluster to create nodes dynamically, and instead rely
    /// only on static nodes.
    pub max_dynamic_node_count: i64,

    /// Additional configuration for the nodeset. If not set, the nodeset will
    /// use
    /// [ComputeInstanceSlurmNodeSet][google.cloud.hypercomputecluster.v1.ComputeInstanceSlurmNodeSet]
    /// with default values.
    ///
    /// [google.cloud.hypercomputecluster.v1.ComputeInstanceSlurmNodeSet]: crate::model::ComputeInstanceSlurmNodeSet
    pub r#type: std::option::Option<crate::model::slurm_node_set::Type>,

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

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

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

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

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

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

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

    /// Sets the value of [r#type][crate::model::SlurmNodeSet::type].
    ///
    /// Note that all the setters affecting `r#type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::SlurmNodeSet;
    /// use google_cloud_hypercomputecluster_v1::model::ComputeInstanceSlurmNodeSet;
    /// let x = SlurmNodeSet::new().set_type(Some(
    ///     google_cloud_hypercomputecluster_v1::model::slurm_node_set::Type::ComputeInstance(ComputeInstanceSlurmNodeSet::default().into())));
    /// ```
    pub fn set_type<
        T: std::convert::Into<std::option::Option<crate::model::slurm_node_set::Type>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// The value of [r#type][crate::model::SlurmNodeSet::r#type]
    /// if it holds a `ComputeInstance`, `None` if the field is not set or
    /// holds a different branch.
    pub fn compute_instance(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::ComputeInstanceSlurmNodeSet>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::slurm_node_set::Type::ComputeInstance(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::SlurmNodeSet::r#type]
    /// to hold a `ComputeInstance`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::SlurmNodeSet;
    /// use google_cloud_hypercomputecluster_v1::model::ComputeInstanceSlurmNodeSet;
    /// let x = SlurmNodeSet::new().set_compute_instance(ComputeInstanceSlurmNodeSet::default()/* use setters */);
    /// assert!(x.compute_instance().is_some());
    /// ```
    pub fn set_compute_instance<
        T: std::convert::Into<std::boxed::Box<crate::model::ComputeInstanceSlurmNodeSet>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::slurm_node_set::Type::ComputeInstance(v.into()),
        );
        self
    }
}

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

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

    /// Additional configuration for the nodeset. If not set, the nodeset will
    /// use
    /// [ComputeInstanceSlurmNodeSet][google.cloud.hypercomputecluster.v1.ComputeInstanceSlurmNodeSet]
    /// with default values.
    ///
    /// [google.cloud.hypercomputecluster.v1.ComputeInstanceSlurmNodeSet]: crate::model::ComputeInstanceSlurmNodeSet
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Optional. If set, indicates that the nodeset should be backed by Compute
        /// Engine instances.
        ComputeInstance(std::boxed::Box<crate::model::ComputeInstanceSlurmNodeSet>),
    }
}

/// When set in a
/// [SlurmNodeSet][google.cloud.hypercomputecluster.v1.SlurmNodeSet], indicates
/// that the nodeset should be backed by Compute Engine VM instances.
///
/// [google.cloud.hypercomputecluster.v1.SlurmNodeSet]: crate::model::SlurmNodeSet
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeInstanceSlurmNodeSet {
    /// Optional. [Startup
    /// script](https://cloud.google.com/compute/docs/instances/startup-scripts/linux)
    /// to be run on each VM instance in the nodeset. Max 256KB.
    pub startup_script: std::string::String,

    /// Optional.
    /// [Labels](https://cloud.google.com/compute/docs/labeling-resources) that
    /// should be applied to each VM instance in the nodeset.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. Boot disk for the compute instance
    pub boot_disk: std::option::Option<crate::model::BootDisk>,

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

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

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

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

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

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

/// Configuration for Slurm partitions in the cluster. Partitions are groups of
/// nodesets, and are how clients specify where their workloads should be run.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SlurmPartition {
    /// Required. ID of the partition, which is how users will identify it. Must
    /// conform to [RFC-1034](https://datatracker.ietf.org/doc/html/rfc1034)
    /// (lower-case, alphanumeric, and at most 63 characters).
    pub id: std::string::String,

    /// Required. IDs of the nodesets that make up this partition. Values must
    /// match
    /// [SlurmNodeSet.id][google.cloud.hypercomputecluster.v1.SlurmNodeSet.id].
    ///
    /// [google.cloud.hypercomputecluster.v1.SlurmNodeSet.id]: crate::model::SlurmNodeSet::id
    pub node_set_ids: std::vec::Vec<std::string::String>,

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

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

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

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

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

/// Configuration for Slurm [login
/// nodes](https://slurm.schedmd.com/quickstart_admin.html#login) in the cluster.
/// Login nodes are Compute Engine VM instances that allow users to access the
/// cluster over SSH.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct SlurmLoginNodes {
    /// Required. Number of login node instances to create.
    pub count: i64,

    /// Required. Name of the zone in which login nodes should run, e.g.,
    /// `us-central1-a`. Must be in the same region as the cluster, and must match
    /// the zone of any other resources specified in the cluster.
    pub zone: std::string::String,

    /// Required. Name of the Compute Engine [machine
    /// type](https://cloud.google.com/compute/docs/machine-resource) to use for
    /// login nodes, e.g. `n2-standard-2`.
    pub machine_type: std::string::String,

    /// Optional. [Startup
    /// script](https://cloud.google.com/compute/docs/instances/startup-scripts/linux)
    /// to be run on each login node instance. Max 256KB.
    /// The script must complete within the system-defined default timeout of 5
    /// minutes. For tasks that require more time, consider running them in the
    /// background using methods such as `&` or `nohup`.
    pub startup_script: std::string::String,

    /// Optional. Whether [OS Login](https://cloud.google.com/compute/docs/oslogin)
    /// should be enabled on login node instances.
    pub enable_os_login: bool,

    /// Optional. Whether login node instances should be assigned [external IP
    /// addresses](https://cloud.google.com/compute/docs/ip-addresses#externaladdresses).
    pub enable_public_ips: bool,

    /// Optional.
    /// [Labels](https://cloud.google.com/compute/docs/labeling-resources) that
    /// should be applied to each login node instance.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Optional. How [storage
    /// resources][google.cloud.hypercomputecluster.v1.StorageResource] should be
    /// mounted on each login node.
    ///
    /// [google.cloud.hypercomputecluster.v1.StorageResource]: crate::model::StorageResource
    pub storage_configs: std::vec::Vec<crate::model::StorageConfig>,

    /// Output only. Information about the login node instances that were created
    /// in Compute Engine.
    pub instances: std::vec::Vec<crate::model::ComputeInstance>,

    /// Optional. Boot disk for the login node.
    pub boot_disk: std::option::Option<crate::model::BootDisk>,

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Description of how a [storage
/// resource][google.cloud.hypercomputecluster.v1.StorageResource] should be
/// mounted on a VM instance.
///
/// [google.cloud.hypercomputecluster.v1.StorageResource]: crate::model::StorageResource
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct StorageConfig {
    /// Required. ID of the storage resource to mount, which must match a key in
    /// the cluster's
    /// [storage_resources][google.cloud.hypercomputecluster.v1.Cluster.storage_resources].
    ///
    /// [google.cloud.hypercomputecluster.v1.Cluster.storage_resources]: crate::model::Cluster::storage_resources
    pub id: std::string::String,

    /// Required. A directory inside the VM instance's file system where the
    /// storage resource should be mounted (e.g., `/mnt/share`).
    pub local_mount: std::string::String,

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

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

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

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

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

/// Details about a Compute Engine
/// [instance](https://cloud.google.com/compute/docs/instances).
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ComputeInstance {
    /// Output only. Name of the VM instance, in the format
    /// `projects/{project}/zones/{zone}/instances/{instance}`.
    pub instance: std::string::String,

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

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

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

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

/// Represents the metadata of the long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    pub verb: std::string::String,

    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// 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,

    /// Output only. API version used to start the operation.
    pub api_version: std::string::String,

    /// Output only. Progress of the operation.
    pub progress: std::option::Option<crate::model::OperationProgress>,

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

impl OperationMetadata {
    /// Creates a new default instance.
    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_hypercomputecluster_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_hypercomputecluster_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_hypercomputecluster_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_hypercomputecluster_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_hypercomputecluster_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 [verb][crate::model::OperationMetadata::verb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_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_hypercomputecluster_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
    }

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

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

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

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

/// Message describing the progress of a cluster mutation long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationProgress {
    /// Output only. Steps and status of the operation.
    pub steps: std::vec::Vec<crate::model::OperationStep>,

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

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

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

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

/// Message describing the status of a single step in a cluster mutation
/// long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationStep {
    /// Output only. State of the operation step.
    pub state: crate::model::operation_step::State,

    /// Step of the operation.
    pub r#type: std::option::Option<crate::model::operation_step::Type>,

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

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

    /// Sets the value of [state][crate::model::OperationStep::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::operation_step::State;
    /// let x0 = OperationStep::new().set_state(State::Waiting);
    /// let x1 = OperationStep::new().set_state(State::InProgress);
    /// let x2 = OperationStep::new().set_state(State::Done);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::operation_step::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [r#type][crate::model::OperationStep::type].
    ///
    /// Note that all the setters affecting `r#type` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateNetwork;
    /// let x = OperationStep::new().set_type(Some(
    ///     google_cloud_hypercomputecluster_v1::model::operation_step::Type::CreateNetwork(CreateNetwork::default().into())));
    /// ```
    pub fn set_type<
        T: std::convert::Into<std::option::Option<crate::model::operation_step::Type>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = v.into();
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateNetwork`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_network(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateNetwork>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateNetwork(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateNetwork`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateNetwork;
    /// let x = OperationStep::new().set_create_network(CreateNetwork::default()/* use setters */);
    /// assert!(x.create_network().is_some());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_network<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateNetwork>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::operation_step::Type::CreateNetwork(v.into()));
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreatePrivateServiceAccess`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_private_service_access(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreatePrivateServiceAccess>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreatePrivateServiceAccess(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreatePrivateServiceAccess`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreatePrivateServiceAccess;
    /// let x = OperationStep::new().set_create_private_service_access(CreatePrivateServiceAccess::default()/* use setters */);
    /// assert!(x.create_private_service_access().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_private_service_access<
        T: std::convert::Into<std::boxed::Box<crate::model::CreatePrivateServiceAccess>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreatePrivateServiceAccess(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateFilestoreInstance`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_filestore_instance(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateFilestoreInstance>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateFilestoreInstance(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateFilestoreInstance`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateFilestoreInstance;
    /// let x = OperationStep::new().set_create_filestore_instance(CreateFilestoreInstance::default()/* use setters */);
    /// assert!(x.create_filestore_instance().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_filestore_instance<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateFilestoreInstance>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreateFilestoreInstance(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateStorageBucket`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_storage_bucket(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateStorageBucket>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateStorageBucket(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateStorageBucket`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateStorageBucket;
    /// let x = OperationStep::new().set_create_storage_bucket(CreateStorageBucket::default()/* use setters */);
    /// assert!(x.create_storage_bucket().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_storage_bucket<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateStorageBucket>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreateStorageBucket(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateLustreInstance`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_lustre_instance(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateLustreInstance>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateLustreInstance(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateLustreInstance`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateLustreInstance;
    /// let x = OperationStep::new().set_create_lustre_instance(CreateLustreInstance::default()/* use setters */);
    /// assert!(x.create_lustre_instance().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_lustre_instance<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateLustreInstance>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreateLustreInstance(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateOrchestrator`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_orchestrator(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateOrchestrator>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateOrchestrator(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateOrchestrator`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateOrchestrator;
    /// let x = OperationStep::new().set_create_orchestrator(CreateOrchestrator::default()/* use setters */);
    /// assert!(x.create_orchestrator().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_orchestrator<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateOrchestrator>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreateOrchestrator(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateNodeset`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_nodeset(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateNodeset>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateNodeset(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateNodeset`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateNodeset;
    /// let x = OperationStep::new().set_create_nodeset(CreateNodeset::default()/* use setters */);
    /// assert!(x.create_nodeset().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_nodeset<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateNodeset>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::operation_step::Type::CreateNodeset(v.into()));
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreatePartition`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_partition(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreatePartition>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreatePartition(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreatePartition`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreatePartition;
    /// let x = OperationStep::new().set_create_partition(CreatePartition::default()/* use setters */);
    /// assert!(x.create_partition().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_partition<
        T: std::convert::Into<std::boxed::Box<crate::model::CreatePartition>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreatePartition(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CreateLoginNode`, `None` if the field is not set or
    /// holds a different branch.
    pub fn create_login_node(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CreateLoginNode>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CreateLoginNode(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CreateLoginNode`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CreateLoginNode;
    /// let x = OperationStep::new().set_create_login_node(CreateLoginNode::default()/* use setters */);
    /// assert!(x.create_login_node().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_create_login_node<
        T: std::convert::Into<std::boxed::Box<crate::model::CreateLoginNode>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CreateLoginNode(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `CheckClusterHealth`, `None` if the field is not set or
    /// holds a different branch.
    pub fn check_cluster_health(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::CheckClusterHealth>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::CheckClusterHealth(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `CheckClusterHealth`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::CheckClusterHealth;
    /// let x = OperationStep::new().set_check_cluster_health(CheckClusterHealth::default()/* use setters */);
    /// assert!(x.check_cluster_health().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_check_cluster_health<
        T: std::convert::Into<std::boxed::Box<crate::model::CheckClusterHealth>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::CheckClusterHealth(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `UpdateOrchestrator`, `None` if the field is not set or
    /// holds a different branch.
    pub fn update_orchestrator(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::UpdateOrchestrator>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::UpdateOrchestrator(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `UpdateOrchestrator`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::UpdateOrchestrator;
    /// let x = OperationStep::new().set_update_orchestrator(UpdateOrchestrator::default()/* use setters */);
    /// assert!(x.update_orchestrator().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_update_orchestrator<
        T: std::convert::Into<std::boxed::Box<crate::model::UpdateOrchestrator>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::UpdateOrchestrator(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `UpdateNodeset`, `None` if the field is not set or
    /// holds a different branch.
    pub fn update_nodeset(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::UpdateNodeset>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::UpdateNodeset(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `UpdateNodeset`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::UpdateNodeset;
    /// let x = OperationStep::new().set_update_nodeset(UpdateNodeset::default()/* use setters */);
    /// assert!(x.update_nodeset().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_update_nodeset<
        T: std::convert::Into<std::boxed::Box<crate::model::UpdateNodeset>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::operation_step::Type::UpdateNodeset(v.into()));
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `UpdatePartition`, `None` if the field is not set or
    /// holds a different branch.
    pub fn update_partition(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::UpdatePartition>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::UpdatePartition(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `UpdatePartition`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::UpdatePartition;
    /// let x = OperationStep::new().set_update_partition(UpdatePartition::default()/* use setters */);
    /// assert!(x.update_partition().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_update_partition<
        T: std::convert::Into<std::boxed::Box<crate::model::UpdatePartition>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::UpdatePartition(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `UpdateLoginNode`, `None` if the field is not set or
    /// holds a different branch.
    pub fn update_login_node(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::UpdateLoginNode>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::UpdateLoginNode(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `UpdateLoginNode`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::UpdateLoginNode;
    /// let x = OperationStep::new().set_update_login_node(UpdateLoginNode::default()/* use setters */);
    /// assert!(x.update_login_node().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_update_login_node<
        T: std::convert::Into<std::boxed::Box<crate::model::UpdateLoginNode>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::UpdateLoginNode(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteOrchestrator`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_orchestrator(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteOrchestrator>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteOrchestrator(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteOrchestrator`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteOrchestrator;
    /// let x = OperationStep::new().set_delete_orchestrator(DeleteOrchestrator::default()/* use setters */);
    /// assert!(x.delete_orchestrator().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_orchestrator<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteOrchestrator>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeleteOrchestrator(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteNodeset`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_nodeset(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteNodeset>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteNodeset(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteNodeset`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteNodeset;
    /// let x = OperationStep::new().set_delete_nodeset(DeleteNodeset::default()/* use setters */);
    /// assert!(x.delete_nodeset().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_nodeset<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteNodeset>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::operation_step::Type::DeleteNodeset(v.into()));
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeletePartition`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_partition(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeletePartition>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeletePartition(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeletePartition`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeletePartition;
    /// let x = OperationStep::new().set_delete_partition(DeletePartition::default()/* use setters */);
    /// assert!(x.delete_partition().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_partition<
        T: std::convert::Into<std::boxed::Box<crate::model::DeletePartition>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeletePartition(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteLoginNode`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_login_node(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteLoginNode>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteLoginNode(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteLoginNode`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteLoginNode;
    /// let x = OperationStep::new().set_delete_login_node(DeleteLoginNode::default()/* use setters */);
    /// assert!(x.delete_login_node().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_login_node<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteLoginNode>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeleteLoginNode(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteFilestoreInstance`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_filestore_instance(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteFilestoreInstance>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteFilestoreInstance(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteFilestoreInstance`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteFilestoreInstance;
    /// let x = OperationStep::new().set_delete_filestore_instance(DeleteFilestoreInstance::default()/* use setters */);
    /// assert!(x.delete_filestore_instance().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_filestore_instance<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteFilestoreInstance>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeleteFilestoreInstance(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteStorageBucket`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_storage_bucket(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteStorageBucket>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteStorageBucket(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteStorageBucket`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteStorageBucket;
    /// let x = OperationStep::new().set_delete_storage_bucket(DeleteStorageBucket::default()/* use setters */);
    /// assert!(x.delete_storage_bucket().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_storage_bucket<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteStorageBucket>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeleteStorageBucket(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteLustreInstance`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_lustre_instance(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteLustreInstance>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteLustreInstance(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteLustreInstance`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteLustreInstance;
    /// let x = OperationStep::new().set_delete_lustre_instance(DeleteLustreInstance::default()/* use setters */);
    /// assert!(x.delete_lustre_instance().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_lustre_instance<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteLustreInstance>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeleteLustreInstance(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeletePrivateServiceAccess`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_private_service_access(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeletePrivateServiceAccess>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeletePrivateServiceAccess(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeletePrivateServiceAccess`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeletePrivateServiceAccess;
    /// let x = OperationStep::new().set_delete_private_service_access(DeletePrivateServiceAccess::default()/* use setters */);
    /// assert!(x.delete_private_service_access().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_network().is_none());
    /// ```
    pub fn set_delete_private_service_access<
        T: std::convert::Into<std::boxed::Box<crate::model::DeletePrivateServiceAccess>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type = std::option::Option::Some(
            crate::model::operation_step::Type::DeletePrivateServiceAccess(v.into()),
        );
        self
    }

    /// The value of [r#type][crate::model::OperationStep::r#type]
    /// if it holds a `DeleteNetwork`, `None` if the field is not set or
    /// holds a different branch.
    pub fn delete_network(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::DeleteNetwork>> {
        #[allow(unreachable_patterns)]
        self.r#type.as_ref().and_then(|v| match v {
            crate::model::operation_step::Type::DeleteNetwork(v) => std::option::Option::Some(v),
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [r#type][crate::model::OperationStep::r#type]
    /// to hold a `DeleteNetwork`.
    ///
    /// Note that all the setters affecting `r#type` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_hypercomputecluster_v1::model::OperationStep;
    /// use google_cloud_hypercomputecluster_v1::model::DeleteNetwork;
    /// let x = OperationStep::new().set_delete_network(DeleteNetwork::default()/* use setters */);
    /// assert!(x.delete_network().is_some());
    /// assert!(x.create_network().is_none());
    /// assert!(x.create_private_service_access().is_none());
    /// assert!(x.create_filestore_instance().is_none());
    /// assert!(x.create_storage_bucket().is_none());
    /// assert!(x.create_lustre_instance().is_none());
    /// assert!(x.create_orchestrator().is_none());
    /// assert!(x.create_nodeset().is_none());
    /// assert!(x.create_partition().is_none());
    /// assert!(x.create_login_node().is_none());
    /// assert!(x.check_cluster_health().is_none());
    /// assert!(x.update_orchestrator().is_none());
    /// assert!(x.update_nodeset().is_none());
    /// assert!(x.update_partition().is_none());
    /// assert!(x.update_login_node().is_none());
    /// assert!(x.delete_orchestrator().is_none());
    /// assert!(x.delete_nodeset().is_none());
    /// assert!(x.delete_partition().is_none());
    /// assert!(x.delete_login_node().is_none());
    /// assert!(x.delete_filestore_instance().is_none());
    /// assert!(x.delete_storage_bucket().is_none());
    /// assert!(x.delete_lustre_instance().is_none());
    /// assert!(x.delete_private_service_access().is_none());
    /// ```
    pub fn set_delete_network<
        T: std::convert::Into<std::boxed::Box<crate::model::DeleteNetwork>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.r#type =
            std::option::Option::Some(crate::model::operation_step::Type::DeleteNetwork(v.into()));
        self
    }
}

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

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

    /// State of the operation step.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// Unspecified state.
        Unspecified,
        /// Initial state before step execution starts.
        Waiting,
        /// Step execution is running in progress.
        InProgress,
        /// Step execution is completed.
        Done,
        /// 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::Waiting => std::option::Option::Some(1),
                Self::InProgress => std::option::Option::Some(2),
                Self::Done => 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("STATE_UNSPECIFIED"),
                Self::Waiting => std::option::Option::Some("WAITING"),
                Self::InProgress => std::option::Option::Some("IN_PROGRESS"),
                Self::Done => std::option::Option::Some("DONE"),
                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::Waiting,
                2 => Self::InProgress,
                3 => Self::Done,
                _ => 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,
                "WAITING" => Self::Waiting,
                "IN_PROGRESS" => Self::InProgress,
                "DONE" => Self::Done,
                _ => 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::Waiting => serializer.serialize_i32(1),
                Self::InProgress => serializer.serialize_i32(2),
                Self::Done => serializer.serialize_i32(3),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

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

    /// Step of the operation.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum Type {
        /// Output only. If set, indicates that new network creation is part of the
        /// operation.
        CreateNetwork(std::boxed::Box<crate::model::CreateNetwork>),
        /// Output only. If set, indicates that new private service access creation
        /// is part of the operation.
        CreatePrivateServiceAccess(std::boxed::Box<crate::model::CreatePrivateServiceAccess>),
        /// Output only. If set, indicates that new Filestore instance creation is
        /// part of the operation.
        CreateFilestoreInstance(std::boxed::Box<crate::model::CreateFilestoreInstance>),
        /// Output only. If set, indicates that new Cloud Storage bucket creation is
        /// part of the operation.
        CreateStorageBucket(std::boxed::Box<crate::model::CreateStorageBucket>),
        /// Output only. If set, indicates that new Lustre instance creation is part
        /// of the operation.
        CreateLustreInstance(std::boxed::Box<crate::model::CreateLustreInstance>),
        /// Output only. If set, indicates that orchestrator creation is part of the
        /// operation.
        CreateOrchestrator(std::boxed::Box<crate::model::CreateOrchestrator>),
        /// Output only. If set, indicates that new nodeset creation is part of the
        /// operation.
        CreateNodeset(std::boxed::Box<crate::model::CreateNodeset>),
        /// Output only. If set, indicates that new partition creation is part of the
        /// operation.
        CreatePartition(std::boxed::Box<crate::model::CreatePartition>),
        /// Output only. If set, indicates that new login node creation is part of
        /// the operation.
        CreateLoginNode(std::boxed::Box<crate::model::CreateLoginNode>),
        /// Output only. If set, indicates that cluster health check is part of the
        /// operation.
        CheckClusterHealth(std::boxed::Box<crate::model::CheckClusterHealth>),
        /// Output only. If set, indicates that an orchestrator update is part of the
        /// operation.
        UpdateOrchestrator(std::boxed::Box<crate::model::UpdateOrchestrator>),
        /// Output only. If set, indicates that nodeset update is part of the
        /// operation.
        UpdateNodeset(std::boxed::Box<crate::model::UpdateNodeset>),
        /// Output only. If set, indicates that partition update is part of the
        /// operation.
        UpdatePartition(std::boxed::Box<crate::model::UpdatePartition>),
        /// Output only. If set, indicates that login node update is part of the
        /// operation.
        UpdateLoginNode(std::boxed::Box<crate::model::UpdateLoginNode>),
        /// Output only. If set, indicates that orchestrator deletion is part of the
        /// operation.
        DeleteOrchestrator(std::boxed::Box<crate::model::DeleteOrchestrator>),
        /// Output only. If set, indicates that nodeset deletion is part of the
        /// operation.
        DeleteNodeset(std::boxed::Box<crate::model::DeleteNodeset>),
        /// Output only. If set, indicates that partition deletion is part of the
        /// operation.
        DeletePartition(std::boxed::Box<crate::model::DeletePartition>),
        /// Output only. If set, indicates that login node deletion is part of the
        /// operation.
        DeleteLoginNode(std::boxed::Box<crate::model::DeleteLoginNode>),
        /// Output only. If set, indicates that Filestore instance deletion is part
        /// of the operation.
        DeleteFilestoreInstance(std::boxed::Box<crate::model::DeleteFilestoreInstance>),
        /// Output only. If set, indicates that Cloud Storage bucket deletion is part
        /// of the operation.
        DeleteStorageBucket(std::boxed::Box<crate::model::DeleteStorageBucket>),
        /// Output only. If set, indicates that Lustre instance deletion is part of
        /// the operation.
        DeleteLustreInstance(std::boxed::Box<crate::model::DeleteLustreInstance>),
        /// Output only. If set, indicates that private service access deletion is
        /// part of the operation.
        DeletePrivateServiceAccess(std::boxed::Box<crate::model::DeletePrivateServiceAccess>),
        /// Output only. If set, indicates that network deletion is part of the
        /// operation.
        DeleteNetwork(std::boxed::Box<crate::model::DeleteNetwork>),
    }
}

/// When set in OperationStep, indicates that a new network should be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateNetwork {
    /// Output only. Name of the network to create, in the format
    /// `projects/{project}/global/networks/{network}`.
    pub network: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that a new private service access should
/// be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreatePrivateServiceAccess {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that a new filestore instance should be
/// created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateFilestoreInstance {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub filestore: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that a new storage bucket should be
/// created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateStorageBucket {
    /// Output only. Name of the bucket.
    pub bucket: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that a new lustre instance should be
/// created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateLustreInstance {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub lustre: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that an orchestrator should be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateOrchestrator {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that a nodeset should be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateNodeset {
    /// Output only. Name of the nodeset to create
    pub nodesets: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a partition should be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreatePartition {
    /// Output only. Name of the partition to create
    pub partitions: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a login node should be created.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateLoginNode {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that cluster health check should be
/// performed.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CheckClusterHealth {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that an orchestrator should be updated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateOrchestrator {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that a nodeset should be updated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateNodeset {
    /// Output only. Name of the nodeset to update
    pub nodesets: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a partition should be updated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdatePartition {
    /// Output only. Name of the partition to update
    pub partitions: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a login node should be updated.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct UpdateLoginNode {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that an orchestrator should be deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteOrchestrator {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that a nodeset should be deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteNodeset {
    /// Output only. Name of the nodeset to delete
    pub nodesets: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a partition should be deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeletePartition {
    /// Output only. Name of the partition to delete
    pub partitions: std::vec::Vec<std::string::String>,

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

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

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

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

/// When set in OperationStep, indicates that a login node should be deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteLoginNode {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates that a Filestore instance should be
/// deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteFilestoreInstance {
    /// Output only. Name of the Filestore instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub filestore: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that Cloud Storage bucket should be
/// deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteStorageBucket {
    /// Output only. Name of the bucket.
    pub bucket: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates that a Lustre instance should be
/// deleted.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteLustreInstance {
    /// Output only. Name of the Managed Lustre instance, in the format
    /// `projects/{project}/locations/{location}/instances/{instance}`
    pub lustre: std::string::String,

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

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

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

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

/// When set in OperationStep, indicates private service access deletion
/// step.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeletePrivateServiceAccess {
    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

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

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

/// When set in OperationStep, indicates network deletion step with the
/// resource name.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct DeleteNetwork {
    /// Output only. Name of the network to delete, in the format
    /// `projects/{project}/global/networks/{network}`.
    pub network: std::string::String,

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

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

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

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